From f932a2d8bf1df3476860df15897dc837371dd780 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Tue, 8 Sep 2026 06:56:06 -0400 Subject: [PATCH 1/3] perf(ixvm): move whole-partition setup into Rust Keep mmap loading, full constant validation, ownership assignment and audit reporting in Rust for the ordinary whole-partition ix check path. Fuse the coverage and ownership scans into a deterministic parallel pass and share the existing shard executor with the Lean refinement driver. Preserve advanced-option fallbacks, sequence file access through IO, and harden manifest framing checks. Add native/bytecode executor, claim and memory-estimate parity tests plus malformed-input and CLI dispatch tests. Full FLT setup measured 42.1s versus approximately 13m38s for the baseline; this is a setup-only comparison, not a completed IxVM execution result. Validated with the Rust kernel and FFI suites, Lean integration tests, lake build ix IxTests, and strict Clippy. --- Ix/Aiur/Protocol.lean | 22 ++ Ix/Cli/CheckCmd.lean | 27 +++ Tests/Cli.lean | 3 + Tests/Cli/NativePartition.lean | 110 +++++++++ Tests/Main.lean | 3 + crates/ffi/src/aiur.rs | 1 + crates/ffi/src/aiur/check.rs | 361 +++++++++++++++++++++++++++++ crates/ffi/src/aiur/check/tests.rs | 278 ++++++++++++++++++++++ crates/ffi/src/aiur/protocol.rs | 144 +++++++++--- crates/ffi/src/lean.rs | 2 + crates/kernel/src/shard.rs | 45 +++- 11 files changed, 949 insertions(+), 47 deletions(-) create mode 100644 Tests/Cli/NativePartition.lean create mode 100644 crates/ffi/src/aiur/check.rs create mode 100644 crates/ffi/src/aiur/check/tests.rs diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index cbb7ae891..cbf933cc2 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -356,6 +356,28 @@ def detectedRamBudgetBytes : IO Nat := do namespace Bytecode.Toplevel +/-- Small result of whole-partition native orchestration. The environment, +manifest, per-constant ownership, witness data, and audit remain Rust-owned. -/ +structure PartitionCheckResult where + constants : Nat + shards : Nat + failures : Nat + elapsedMs : Nat + deriving Inhabited + +/-- Full-partition execution without a refinement budget, shard selection, or +proof-cache reuse. Rust memory-maps the input, validates and assigns every +constant in one pass, then invokes the same shard executor as the wave API. +An empty `report` string omits the audit file. File reads and report writes +are sequenced through `IO`; this is not a pure function of the path strings. -/ +@[extern "rs_aiur_check_partition"] +opaque checkPartition (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (ixe manifest : @& String) + (jobs : @& Nat) (useBytecode : Bool) + (commitment : @& CommitmentParameters) (fri : @& FriParameters) + (report revision command budgetSource : @& String) : + IO (Except String PartitionCheckResult) + /-- One shard's result from `shardCheckBatchWithEnv`. -/ structure ShardResult where error : String diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 9de6950fc..691aa4d2f 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -1040,6 +1040,33 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- (`peakTreeRssBytes` reports 0 otherwise); started before the env -- load so the peak covers the whole run, like `check-rs`. if json?.isSome then TracingTexray.startSampler + -- The common whole-partition execution path keeps all environment-sized + -- work in Rust. Advanced refinement/selection/cache guards below retain + -- their existing driver; none may silently fall through to an all-shard run. + if maxRamBytes == 0 && outIxes.isNone && opts.selection.isNone && + opts.provenGuard.isNone && !opts.emitOnFailure then + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let result ← compiled.bytecode.checkPartition funIdx ixePath manifestPath + (jobs?.getD 0) useBytecode Aiur.defaultCommitmentParameters + Aiur.defaultFriParameters (opts.report.getD "") (← gitRevision) + opts.command opts.budgetSource + match result with + | .error e => IO.eprintln s!"native partition check: {e}"; return 1 + | .ok r => + if let some (path, key) := json? then + let secs := r.elapsedMs.toFloat / 1000.0 + let tput := if r.elapsedMs > 0 + then r.constants.toFloat * 1000.0 / r.elapsedMs.toFloat else 0.0 + let peakRss ← TracingTexray.peakTreeRssBytes + Ix.Benchmark.Results.writeRow path key + (if r.failures == 0 then "ok" else "rejected") + [ ("constants", Lean.toJson r.constants) + , ("shards", Lean.toJson r.shards) + , ("check-time", Ix.Benchmark.Results.jsonRound 3 secs) + , ("throughput", Ix.Benchmark.Results.jsonRound 2 tput) + , ("peak-rss", Lean.toJson peakRss) ] + if r.failures == 0 then return 0 + return if json?.isSome then Ix.Benchmark.Results.exitRejected else 1 match (← loadEnvAndShards manifestPath ixePath) with | .error e => IO.eprintln e; return 1 | .ok (ixonEnv, shards) => diff --git a/Tests/Cli.lean b/Tests/Cli.lean index 973ce4754..37f86f3f1 100644 --- a/Tests/Cli.lean +++ b/Tests/Cli.lean @@ -1,5 +1,7 @@ module +public import Tests.Cli.NativePartition + /- Integration tests for the Ix CLI -/ def Tests.Cli.run (buildCmd: String) (buildArgs : Array String) (buildDir : Option System.FilePath) : IO Unit := do @@ -51,6 +53,7 @@ private def Tests.Cli.testCompileNoBuild : IO Unit := do public def Tests.Cli.suite : IO UInt32 := do Tests.Cli.run "lake" (#["exe", "ix", "--help"]) none Tests.Cli.testCompileNoBuild + Tests.Cli.NativePartition.run --Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none --Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none return 0 diff --git a/Tests/Cli/NativePartition.lean b/Tests/Cli/NativePartition.lean new file mode 100644 index 000000000..381b208c6 --- /dev/null +++ b/Tests/Cli/NativePartition.lean @@ -0,0 +1,110 @@ +module + +public import Ix.Cli.CheckCmd + +namespace Tests.Cli.NativePartition + +private def expect (condition : Bool) (message : String) : IO Unit := do + unless condition do throw <| IO.userError message + +private def manifestBytes (shards : Array (Array Address)) : ByteArray := Id.run do + let mut out : ByteArray := ⟨#[0x49, 0x58, 0x45, 0x53, 0, 0, 0, 0] ++ Array.replicate 16 0⟩ + out := out ++ shards.size.toUInt32.toLEBytes + for (blocks, id) in shards.mapIdx (fun id blocks => (blocks, id)) do + out := out ++ id.toUInt32.toLEBytes ++ ⟨Array.replicate 25 0⟩ + out := out ++ blocks.size.toUInt32.toLEBytes + for block in blocks do out := out ++ block.hash + out := out ++ (0 : UInt32).toLEBytes + -- Explicit absent aggregation tree and measured peaks (legacy-compatible). + return out ++ ⟨#[0, 0]⟩ + +public def run : IO Unit := do + let dependency : Ixon.Constant := + ⟨.axio ⟨false, 0, .sort 0⟩, #[], #[], #[.succ .zero]⟩ + let dependencyAddr := Address.blake3 (Ixon.serConstant dependency) + let consumer : Ixon.Constant := + ⟨.axio ⟨false, 0, .ref 0 #[]⟩, #[], #[dependencyAddr], #[]⟩ + let consumerAddr := Address.blake3 (Ixon.serConstant consumer) + let env := (({} : Ixon.Env).storeConst dependencyAddr dependency) + |>.storeConst consumerAddr consumer + let shards := #[#[consumerAddr], #[dependencyAddr]] + let bytes ← IO.ofExcept (Ixon.serEnv env) + let dir ← IO.FS.createTempDir + try + let ixe := dir / "fixture.ixe" + let ixes := dir / "fixture.ixes" + let report := dir / "report.json" + IO.FS.writeBinFile ixe bytes + IO.FS.writeBinFile ixes (manifestBytes shards) + let toplevel ← IO.ofExcept IxVM.ixVM + let compiled ← IO.ofExcept toplevel.compile + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let check := fun bytecode jobs => compiled.bytecode.checkPartition funIdx + ixe.toString ixes.toString jobs bytecode Aiur.defaultCommitmentParameters + Aiur.defaultFriParameters report.toString "test" "ix check" "none" + let legacyHandle ← IO.ofExcept (Aiur.EnvHandle.fromBytes bytes) + let owned := Ix.Cli.CheckCmd.ownedConstsPer env shards + expect (← Ix.Cli.CheckCmd.shardsCover env shards) "reference coverage failed" + for bytecode in [false, true] do + let native ← IO.ofExcept (← check bytecode 2) + expect (native.constants == 2 && native.shards == 2 && native.failures == 0) + "native full-partition execution/counts failed" + let legacy ← IO.ofExcept (compiled.bytecode.shardCheckBatchWithEnv funIdx + legacyHandle (Ix.Cli.CheckCmd.addrListsBlob owned) bytecode 2) + expect (legacy.size == 2 && legacy.all (·.error.isEmpty)) + "legacy shard execution disagrees with native setup" + let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) + let leaves ← IO.ofExcept (audit.getObjValAs? (Array Lean.Json) "leaves") + expect (leaves.size == 2) "native audit omitted leaves" + for (addresses, id) in owned.mapIdx (fun id addresses => (addresses, id)) do + let (claim, _) ← IO.ofExcept (IxVM.ClaimHarness.shardCheckEnvClaimTrees env addresses) + let expected := toString (Address.blake3 (Ix.Claim.ser claim)) + let actual ← IO.ofExcept (leaves[id]!.getObjValAs? String "claim") + expect (actual == expected) "native audit changed a shard claim digest" + let peak ← IO.ofExcept (leaves[id]!.getObjValAs? Nat "predicted_peak_bytes") + expect (peak == legacy[id]!.peakBytes) "native execution record/peak disagrees with legacy" + -- Exercise actual CLI dispatch and ensure options that still need the + -- legacy wave driver are never silently ignored by the native fast path. + let ix ← IO.FS.realPath ".lake/build/bin/ix" + for (extra, nativePath, selected, budget) in + [(#[], true, 2, 0), (#["--shards", "0"], false, 1, 0), + (#["--ram-budget", "1"], false, 2, 1024 * 1024 * 1024)] do + let out ← IO.Process.output { cmd := ix.toString, args := + #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, + "--jobs", "2", "--report", report.toString, + "--json", (dir / "results.json").toString] ++ extra } + expect (out.exitCode == 0) s!"partition CLI failed: {out.stdout}\n{out.stderr}" + expect (out.stderr.contains "[ixvm_setup]" == nativePath) + "partition CLI routed to the wrong setup path" + let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) + expect ((← IO.ofExcept (audit.getObjValAs? Nat "selected")) == selected) + "partition CLI ignored a shard selection" + expect ((← IO.ofExcept (audit.getObjValAs? Nat "budget_bytes")) == budget) + "partition CLI ignored a refinement budget" + -- Invalid coverage must fail setup, never return successful partial work. + -- Reuse the path strings after file writes: the IO FFI must read new bytes. + for invalid in [#[#[consumerAddr]], #[#[consumerAddr, dependencyAddr], #[dependencyAddr]]] do + IO.FS.writeBinFile ixes (manifestBytes invalid) + expect (!(← check false 2).isOk) "native setup accepted incomplete/duplicate ownership" + -- Both readers must reject malformed trailing manifest data. + let trailing := (manifestBytes shards).push 0 + IO.FS.writeBinFile ixes trailing + expect (!(Ix.Cli.CheckCmd.parseIxesManifest trailing).isOk) "reference parser accepted trailing bytes" + expect (!(← check false 2).isOk) "native parser accepted trailing bytes" + IO.FS.writeBinFile ixes (manifestBytes shards) + let restored ← IO.ofExcept (← check false 2) + expect (restored.failures == 0) "native setup reused a stale path-based result" + -- A well-framed but ill-typed constant reaches execution and is rejected, + -- rather than being mistaken for a successful setup/coverage result. + let bad : Ixon.Constant := ⟨.axio ⟨false, 0, .ref 99 #[]⟩, #[], #[], #[]⟩ + let badAddr := Address.blake3 (Ixon.serConstant bad) + IO.FS.writeBinFile ixe (← IO.ofExcept (Ixon.serEnv (({} : Ixon.Env).storeConst badAddr bad))) + IO.FS.writeBinFile ixes (manifestBytes #[#[badAddr]]) + let rejected ← IO.ofExcept (← check false 1) + expect (rejected.constants == 1 && rejected.shards == 1 && rejected.failures == 1) + "native full-partition execution accepted an invalid constant" + IO.println "native partition: executor/claim/peak parity and fail-closed setup passed" + finally + IO.FS.removeDirAll dir + +end Tests.Cli.NativePartition diff --git a/Tests/Main.lean b/Tests/Main.lean index fb6d83d8b..c75ca7c84 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -335,6 +335,9 @@ def main (args : List String) : IO UInt32 := do return 0 -- Special case: cli tests have their own runner + if args.contains "native-partition" then + Tests.Cli.NativePartition.run + return 0 if args.contains "cli" then return ← Tests.Cli.suite diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs index 543b5f5ea..7bc3f1d19 100644 --- a/crates/ffi/src/aiur.rs +++ b/crates/ffi/src/aiur.rs @@ -1,6 +1,7 @@ use multi_stark::p3_field::integers::QuotientMap; pub mod aggregate; +mod check; pub mod protocol; pub mod toplevel; diff --git a/crates/ffi/src/aiur/check.rs b/crates/ffi/src/aiur/check.rs new file mode 100644 index 000000000..3e1c182d2 --- /dev/null +++ b/crates/ffi/src/aiur/check.rs @@ -0,0 +1,361 @@ +//! Native startup for a whole-partition `ix check`. Only small result counts +//! cross the FFI: the mmap, manifest, ownership lists and audit stay in Rust. +//! The kernel/witness executor is shared with the existing Lean wave driver. + +use std::{fs, path::Path, sync::Arc, time::Instant}; + +use aiur::{bytecode::Toplevel, synthesis::AiurSystem}; +use ix_common::address::Address; +use ix_kernel::shard::ShardManifest; +use ixon::{ConstantInfo, Env}; +use lean_ffi::object::{ + LeanBorrowed, LeanExcept, LeanIOResult, LeanNat, LeanOwned, LeanString, +}; +use rayon::prelude::*; +use rustc_hash::FxHashMap; +use serde_json::{Value, json}; + +use super::{ + lean_unbox_nat_as_usize, + protocol::{ + ShardCheckResult, check_shard_batch, decode_commitment_parameters, + decode_fri_parameters, + }, + toplevel::decode_toplevel, +}; +use crate::lean::{ + LeanAiurCommitmentParameters, LeanAiurFriParameters, + LeanAiurPartitionCheckResult, LeanAiurToplevel, +}; + +/// Validate every serialized body and assign it to exactly one shard, in a +/// single parallel pass. Do not replace parsing with a header-only peek: an +/// unparseable constant must fail coverage even if no other constant uses it. +/// Projection wrappers belong to their block, not to their own address. +fn prepare_owned( + env: &Env, + manifest: &ShardManifest, +) -> Result>, String> { + if manifest.shards.is_empty() { + return Err("manifest contains no shards".into()); + } + let mut block_to_shard = FxHashMap::default(); + for (index, shard) in manifest.shards.iter().enumerate() { + // The CLI's Lean parser requires dense, ascending ids. Keep that gate + // even though the general Rust manifest representation permits other ids. + if usize::try_from(shard.id).ok() != Some(index) { + return Err(format!("manifest shard entry {index} has id {}", shard.id)); + } + for block in &shard.blocks { + if let Some(previous) = block_to_shard.insert(block.clone(), index) { + return Err(format!( + "block {} is owned more than once (shards {previous} and {index})", + block.hex(), + )); + } + } + } + let mut addresses: Vec
= + env.consts.iter().map(|e| e.key().clone()).collect(); + addresses.par_sort_unstable(); + // Indexed collection makes both ownership ordering and the first error + // independent of Rayon scheduling; no partially validated plan escapes. + let classified: Vec> = addresses + .par_iter() + .map(|addr| { + let lc = env + .consts + .get(addr) + .ok_or_else(|| format!("constant {} disappeared", addr.hex()))?; + if !lc.verify_address(addr) { + return Err(format!( + "constant {}: content-address mismatch", + addr.hex() + )); + } + let constant = lc.get().map_err(|error| { + format!("cannot parse constant {}: {error}", addr.hex()) + })?; + let block = match &constant.info { + ConstantInfo::IPrj(p) => &p.block, + ConstantInfo::CPrj(p) => &p.block, + ConstantInfo::RPrj(p) => &p.block, + ConstantInfo::DPrj(p) => &p.block, + _ => addr, + }; + block_to_shard.get(block).copied().ok_or_else(|| { + format!( + "constant {} (block {}) has no owning shard", + addr.hex(), + block.hex(), + ) + }) + }) + .collect(); + let owners = classified.into_iter().collect::, _>>()?; + let mut owned = vec![Vec::new(); manifest.shards.len()]; + for (addr, owner) in addresses.into_iter().zip(owners) { + owned[owner].push(addr); + } + Ok(owned) +} + +struct LoadedEnv { + env: Env, + /// Diagnostic alias only; never used for ownership or checking decisions. + names: FxHashMap, + bytes: usize, +} + +fn load_env(path: &Path, keep_names: bool) -> Result { + let file = fs::File::open(path) + .map_err(|e| format!("open {}: {e}", path.display()))?; + // As for the existing Env mmap reader, the input must not be modified or + // truncated while this run holds the mapping. No path here writes the input. + let mmap = Arc::new( + unsafe { memmap2::Mmap::map(&file) } + .map_err(|e| format!("mmap {}: {e}", path.display()))?, + ); + // Same metadata-light decoder as Lean deEnvAnon, including validation of + // every section. Avoid materializing the 28 GiB input as a Lean ByteArray. + let index = Env::parse_lazy_index(&mmap)?; + let env = Env::from_lazy_index_mmap(&index, &mmap)?; + let names = if keep_names { + // Match registerName's last diagnostic alias for an address. Aliases + // cannot be collapsed for semantic name resolution, which is not used here. + index.named.iter().map(|n| (n.addr.clone(), n.name.pretty())).collect() + } else { + FxHashMap::default() + }; + Ok(LoadedEnv { env, names, bytes: mmap.len() }) +} + +struct RunConfig<'a> { + ixe: &'a Path, + manifest: &'a Path, + jobs: usize, + use_bytecode: bool, + report: &'a str, + revision: &'a str, + command: &'a str, + budget_source: &'a str, +} + +struct CheckSummary { + constants: usize, + shards: usize, + failures: usize, + elapsed_ms: usize, +} + +fn audit_report( + config: &RunConfig<'_>, + loaded: &LoadedEnv, + manifest: &ShardManifest, + manifest_bytes: &[u8], + owned: &[Vec
], + results: &[ShardCheckResult], +) -> Value { + let mut leaves = Vec::new(); + let mut failures = Vec::new(); + for (id, ((shard, owned), result)) in + manifest.shards.iter().zip(owned).zip(results).enumerate() + { + // Usually already computed by the witness builder. Empty/failed witness + // builds retain the same nullable claim field as the old audit path. + let claim = result.claim.clone().or_else(|| { + let (claim, _) = + ixon::shard_claim::shard_check_env_claim(&loaded.env, owned)?; + let mut bytes = Vec::new(); + claim.put(&mut bytes); + Some(Address::hash(&bytes)) + }); + leaves.push(json!({ + "id": id, "blocks": shard.blocks.len(), "consts": owned.len(), + "claim": claim.map(|a| a.hex()), "predicted_peak_bytes": result.peak_bytes, + "status": if result.error.is_empty() { "measured" } else { "failed" }, + })); + if !result.error.is_empty() { + let names: Vec<&String> = + owned.iter().filter_map(|a| loaded.names.get(a)).take(8).collect(); + let mut failure = json!({ + "id": id, "label": id.to_string(), "reason": result.error, + "blocks": shard.blocks.len(), "consts": owned.len(), + "predicted_peak_bytes": result.peak_bytes, "names": names, + }); + if shard.blocks.len() == 1 { + failure["block"] = json!(shard.blocks[0].hex()); + } + failures.push(failure); + } + } + json!({ + "schema": "ix-refine/0", "revision": config.revision, "command": config.command, + "env": { "path": config.ixe, "bytes": loaded.bytes }, + "source": { "path": config.manifest, "bytes": manifest_bytes.len(), + "blake3": blake3::hash(manifest_bytes).to_hex().to_string(), "shards": manifest.shards.len() }, + "out": null, "budget_bytes": 0, "budget_source": config.budget_source, + "jobs": config.jobs, "selected": manifest.shards.len(), "executed": manifest.shards.len(), + "waves": 0, "consolidation_shards": null, "leaves": leaves, "failures": failures, + }) +} + +fn run_partition( + toplevel: &Toplevel, + fun_idx: usize, + build_system: impl FnOnce() -> AiurSystem, + config: &RunConfig<'_>, +) -> Result { + let started = Instant::now(); + eprintln!("[ixvm_setup] loading manifest and metadata-light mmap"); + let manifest_bytes = fs::read(config.manifest) + .map_err(|e| format!("read {}: {e}", config.manifest.display()))?; + let manifest = ShardManifest::from_bytes(&manifest_bytes) + .map_err(|e| format!("manifest parse failed: {e}"))?; + let loaded = load_env(config.ixe, !config.report.is_empty())?; + let loaded_at = Instant::now(); + eprintln!( + "[ixvm_setup] loaded in {:.3}s; validating coverage and assigning ownership in Rust", + (loaded_at - started).as_secs_f64() + ); + let owned = prepare_owned(&loaded.env, &manifest)?; + eprintln!( + "[shards] OK: partition covers all {} consts, disjoint ({} shards)", + loaded.env.consts.len(), + owned.len() + ); + eprintln!( + "[ixvm_setup] coverage/ownership {:.3}s; total startup {:.3}s", + loaded_at.elapsed().as_secs_f64(), + started.elapsed().as_secs_f64() + ); + eprintln!( + "Typechecking {} shard(s) in one rayon batch, {} thread(s) (0 = all)", + owned.len(), + config.jobs + ); + let execution_start = Instant::now(); + // Keep circuit/peak-model construction in the execution measurement, + // matching the legacy shardCheckBatchWithEnv timing boundary. + let system = build_system(); + // The caller installed the requested pool for both preparation and checking. + let results = check_shard_batch( + toplevel, + fun_idx, + &loaded.env, + &owned, + config.use_bytecode, + 0, + &system, + 0, + true, + )?; + let elapsed_ms = usize::try_from(execution_start.elapsed().as_millis()) + .unwrap_or(usize::MAX); + let failures = results.iter().filter(|r| !r.error.is_empty()).count(); + if !config.report.is_empty() { + let report = audit_report( + config, + &loaded, + &manifest, + &manifest_bytes, + &owned, + &results, + ); + let mut bytes = serde_json::to_vec_pretty(&report) + .map_err(|e| format!("audit JSON: {e}"))?; + bytes.push(b'\n'); + fs::write(config.report, bytes) + .map_err(|e| format!("write audit {}: {e}", config.report))?; + eprintln!("[split-audit] report → {}", config.report); + } + if failures == 0 { + eprintln!("All {} shard(s) passed", owned.len()); + } else { + eprintln!("{failures} of {} shard(s) FAILED", owned.len()); + } + Ok(CheckSummary { + constants: loaded.env.consts.len(), + shards: owned.len(), + failures, + elapsed_ms, + }) +} + +/// Full-partition, no-refinement execution. Advanced split/selection/proof-cache +/// paths keep the existing driver until their orchestration is ported too. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_check_partition( + toplevel_obj: LeanAiurToplevel>, + fun_idx: LeanNat>, + ixe: LeanString>, + manifest: LeanString>, + jobs: LeanNat>, + use_bytecode: bool, + commitment: LeanAiurCommitmentParameters>, + fri: LeanAiurFriParameters>, + report: LeanString>, + revision: LeanString>, + command: LeanString>, + budget_source: LeanString>, +) -> LeanIOResult { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let toplevel = decode_toplevel(&toplevel_obj); + let system_toplevel = decode_toplevel(&toplevel_obj); + let commitment = decode_commitment_parameters(&commitment); + let fri = decode_fri_parameters(&fri); + let config = RunConfig { + ixe: Path::new(ixe.as_str()), + manifest: Path::new(manifest.as_str()), + jobs: lean_unbox_nat_as_usize(jobs.inner()), + use_bytecode, + report: report.as_str(), + revision: revision.as_str(), + command: command.as_str(), + budget_source: budget_source.as_str(), + }; + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let run = || { + run_partition( + &toplevel, + fun_idx, + || AiurSystem::build(system_toplevel, commitment, fri), + &config, + ) + }; + if config.jobs == 0 { + run() + } else { + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(config.jobs) + .build() + .map_err(|e| format!("rayon pool: {e}"))?; + pool.install(run) + } + })); + let result = match result { + Ok(Ok(summary)) => { + let out = LeanAiurPartitionCheckResult::alloc(0); + out.set_obj(0, LeanOwned::box_usize(summary.constants)); + out.set_obj(1, LeanOwned::box_usize(summary.shards)); + out.set_obj(2, LeanOwned::box_usize(summary.failures)); + out.set_obj(3, LeanOwned::box_usize(summary.elapsed_ms)); + LeanExcept::ok(out) + }, + Ok(Err(error)) => LeanExcept::error_string(&error), + Err(payload) => { + let msg = payload + .downcast_ref::() + .map(String::as_str) + .or_else(|| payload.downcast_ref::<&str>().copied()) + .unwrap_or("unknown panic"); + LeanExcept::error_string(&format!( + "native partition check panicked: {msg}" + )) + }, + }; + LeanIOResult::ok(result) +} + +#[cfg(test)] +mod tests; diff --git a/crates/ffi/src/aiur/check/tests.rs b/crates/ffi/src/aiur/check/tests.rs new file mode 100644 index 000000000..18952df0f --- /dev/null +++ b/crates/ffi/src/aiur/check/tests.rs @@ -0,0 +1,278 @@ +use super::*; +use ix_kernel::shard::{AggNode, ShardInfo}; +use ixon::{Constant, constant::Axiom, expr::Expr}; + +fn store(env: &Env, constant: &Constant) -> Address { + let mut bytes = Vec::new(); + constant.put(&mut bytes); + let addr = Address::hash(&bytes); + // Test the actual lazy full-parse path, not the compile-side cached value. + env.store_const_lazy(addr.clone(), Arc::from(bytes)); + addr +} + +fn axiom(env: &Env, level: u64) -> Address { + store( + env, + &Constant { + info: ConstantInfo::Axio(Axiom { + is_unsafe: false, + lvls: level, + typ: Expr::sort(0), + }), + sharing: Vec::new(), + refs: Vec::new(), + univs: Vec::new(), + }, + ) +} + +fn manifest(lists: Vec>) -> ShardManifest { + ShardManifest { + num_shards: u32::try_from(lists.len()).unwrap(), + shards: lists + .into_iter() + .enumerate() + .map(|(id, blocks)| ShardInfo { + id: u32::try_from(id).unwrap(), + blocks, + heartbeats: 0, + own_size: 0, + foreign_blocks: Vec::new(), + cross_ingress: 0, + assumption_root: None, + measured_peak_bytes: 0, + }) + .collect(), + total_cross_ingress: 0, + tree: None, + } +} + +#[test] +fn native_ownership_covers_every_constant_and_preserves_empty_leaves() { + let env = Env::new(); + let a = axiom(&env, 0); + let b = axiom(&env, 1); + let m = manifest(vec![vec![a.clone()], vec![], vec![b.clone()]]); + assert_eq!(prepare_owned(&env, &m).unwrap(), vec![vec![a], vec![], vec![b]]); +} + +#[test] +fn every_projection_variant_is_owned_with_its_block() { + use ixon::constant::{ + ctor_proj_constant, defn_proj_constant, indc_proj_constant, + recr_proj_constant, + }; + let env = Env::new(); + // This test exercises scheduling, not semantic validity of the block. + // Only IxVM execution may certify that the projection itself is well typed. + let block = axiom(&env, 0); + let projections = [ + indc_proj_constant(0, block.clone()), + ctor_proj_constant(0, 0, block.clone()), + recr_proj_constant(0, block.clone()), + defn_proj_constant(0, block.clone()), + ] + .map(|constant| store(&env, &constant)); + let mut expected = vec![block.clone()]; + expected.extend(projections.iter().cloned()); + expected.sort_unstable(); + let owned = + prepare_owned(&env, &manifest(vec![vec![], vec![block.clone()]])).unwrap(); + assert_eq!(owned, vec![vec![], expected]); + // Listing wrapper addresses cannot substitute for owning their block. + assert!(prepare_owned(&env, &manifest(vec![projections.to_vec()])).is_err()); + env.consts.remove(&block); + assert!(prepare_owned(&env, &manifest(vec![projections.to_vec()])).is_err()); +} + +#[test] +fn native_ownership_rejects_duplicate_blocks_even_within_one_shard() { + let env = Env::new(); + let a = axiom(&env, 0); + for lists in + [vec![vec![a.clone(), a.clone()]], vec![vec![a.clone()], vec![a]]] + { + assert!( + prepare_owned(&env, &manifest(lists)) + .unwrap_err() + .contains("owned more than once") + ); + } +} + +#[test] +fn native_ownership_rejects_gaps_empty_manifests_and_noncanonical_ids() { + let env = Env::new(); + let a = axiom(&env, 0); + assert!( + prepare_owned(&env, &manifest(vec![vec![]])) + .unwrap_err() + .contains("no owning shard") + ); + assert!( + prepare_owned(&env, &manifest(vec![])).unwrap_err().contains("no shards") + ); + let mut m = manifest(vec![vec![a]]); + m.shards[0].id = 42; + assert!(prepare_owned(&env, &m).unwrap_err().contains("entry 0 has id 42")); +} + +#[test] +fn native_ownership_rejects_unreferenced_malformed_bodies() { + let env = Env::new(); + let good = axiom(&env, 0); + let bytes = vec![0xff]; + let bad = Address::hash(&bytes); + env.store_const_lazy(bad.clone(), Arc::from(bytes)); + let error = + prepare_owned(&env, &manifest(vec![vec![good, bad]])).unwrap_err(); + assert!(error.contains("cannot parse constant"), "{error}"); +} + +#[test] +fn native_ownership_rejects_hash_mismatches_and_trailing_constant_bytes() { + let env = Env::new(); + let good = axiom(&env, 0); + let mut bytes = env.get_const_bytes(&good).unwrap().to_vec(); + bytes.push(0); + env.store_const_lazy(good.clone(), Arc::from(bytes.clone())); + assert!( + prepare_owned(&env, &manifest(vec![vec![good.clone()]])) + .unwrap_err() + .contains("content-address mismatch") + ); + env.consts.remove(&good); + let bad = Address::hash(&bytes); + env.store_const_lazy(bad.clone(), Arc::from(bytes)); + assert!( + prepare_owned(&env, &manifest(vec![vec![bad]])) + .unwrap_err() + .contains("trailing") + ); +} + +#[test] +fn native_ownership_and_error_order_are_deterministic_across_pool_widths() { + let env = Env::new(); + let mut addresses: Vec<_> = (0..40).map(|i| axiom(&env, i)).collect(); + addresses.sort_unstable(); + let m = manifest(vec![addresses.iter().cloned().rev().collect()]); + let run = |width, manifest: &ShardManifest| { + rayon::ThreadPoolBuilder::new() + .num_threads(width) + .build() + .unwrap() + .install(|| prepare_owned(&env, manifest)) + }; + assert_eq!(run(1, &m).unwrap(), run(4, &m).unwrap()); + assert_eq!(run(4, &m).unwrap()[0], addresses); + let missing = manifest(vec![vec![]]); + assert_eq!(run(1, &missing).unwrap_err(), run(4, &missing).unwrap_err()); +} + +#[test] +fn native_manifest_decoder_rejects_malformed_framing() { + let env = Env::new(); + let a = axiom(&env, 0); + let m = manifest(vec![vec![a]]); + let valid = m.to_bytes(); + assert_eq!(ShardManifest::from_bytes(&valid).unwrap(), m); + let mut trailing = valid.clone(); + trailing.push(0); + assert!(ShardManifest::from_bytes(&trailing).is_err()); + // Header(28), id(4), three u64 fields(24), assumption-root tag. + let mut bad_tag = valid.clone(); + bad_tag[56] = 2; + assert!(ShardManifest::from_bytes(&bad_tag).is_err()); + let mut huge_count = valid.clone(); + huge_count[24..28].copy_from_slice(&u32::MAX.to_le_bytes()); + assert!(ShardManifest::from_bytes(&huge_count).is_err()); + // The writer prunes unknown tree leaves. Corrupt the bytes of a valid + // serialized tree instead, so this actually reaches the reader's check. + let mut with_tree = m; + with_tree.tree = Some(AggNode::Leaf(0)); + let mut bad_tree = with_tree.to_bytes(); + let leaf_offset = bad_tree.len() - 5; + bad_tree[leaf_offset..leaf_offset + 4].copy_from_slice(&7u32.to_le_bytes()); + assert!(ShardManifest::from_bytes(&bad_tree).is_err()); + let mut bad_presence = valid.clone(); + let tree_offset = bad_presence.len() - 2; + bad_presence[tree_offset] = 2; + assert!(ShardManifest::from_bytes(&bad_presence).is_err()); + let mut bad_peak_presence = valid; + *bad_peak_presence.last_mut().unwrap() = 2; + assert!(ShardManifest::from_bytes(&bad_peak_presence).is_err()); +} + +#[test] +fn native_report_keeps_claim_identity_and_rejected_leaf_details() { + let env = Env::new(); + let address = axiom(&env, 0); + let m = manifest(vec![vec![address.clone()]]); + let owned = prepare_owned(&env, &m).unwrap(); + let (claim, _) = + ixon::shard_claim::shard_check_env_claim(&env, &owned[0]).unwrap(); + let mut bytes = Vec::new(); + claim.put(&mut bytes); + let digest = Address::hash(&bytes); + let config = RunConfig { + ixe: Path::new("fixture.ixe"), + manifest: Path::new("fixture.ixes"), + jobs: 2, + use_bytecode: true, + report: "report.json", + revision: "test", + command: "ix check", + budget_source: "none", + }; + let loaded = LoadedEnv { + env, + names: [(address.clone(), "Fixture.marker".to_owned())] + .into_iter() + .collect(), + bytes: 42, + }; + let results = [ShardCheckResult { + error: "expected rejection".into(), + peak_bytes: 0, + suggested_parts: 1, + claim: Some(digest.clone()), + }]; + let report = + audit_report(&config, &loaded, &m, &m.to_bytes(), &owned, &results); + assert_eq!(report["leaves"][0]["claim"], digest.hex()); + assert_eq!(report["leaves"][0]["status"], "failed"); + assert_eq!(report["failures"][0]["block"], address.hex()); + assert_eq!(report["failures"][0]["names"][0], "Fixture.marker"); + assert_eq!(report["selected"], 1); + assert_eq!(report["executed"], 1); +} + +/// Release-mode setup benchmark for external corpora. Deliberately does not +/// execute shards: it can measure the new loader/coverage pass alongside a +/// running baseline without creating a second set of execution records. +#[test] +#[ignore = "requires IX_TEST_PARTITION_IXE and IX_TEST_PARTITION_IXES"] +fn large_fixture_setup_only() { + let ixe = + std::env::var("IX_TEST_PARTITION_IXE").expect("IX_TEST_PARTITION_IXE"); + let ixes = + std::env::var("IX_TEST_PARTITION_IXES").expect("IX_TEST_PARTITION_IXES"); + let started = Instant::now(); + let manifest = ShardManifest::from_bytes(&fs::read(&ixes).unwrap()).unwrap(); + let loaded = load_env(Path::new(&ixe), true).unwrap(); + let loaded_at = Instant::now(); + let owned = prepare_owned(&loaded.env, &manifest).unwrap(); + let total: usize = owned.iter().map(Vec::len).sum(); + assert_eq!(total, loaded.env.consts.len()); + eprintln!( + "[ixvm_setup_bench] {} constants, {} shards; load {:.3}s; coverage/ownership {:.3}s; total {:.3}s; execution NOT run", + total, + owned.len(), + (loaded_at - started).as_secs_f64(), + loaded_at.elapsed().as_secs_f64(), + started.elapsed().as_secs_f64() + ); +} diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 5dac21c9c..27737bd91 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -761,7 +761,6 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( fri_parameters: LeanAiurFriParameters>, max_ram_bytes: LeanNat>, ) -> LeanExcept { - use rayon::prelude::*; let toplevel = decode_toplevel(&toplevel_obj); let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); let jobs = lean_unbox_nat_as_usize(jobs.inner()); @@ -778,6 +777,58 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( decode_commitment_parameters(&commitment_parameters), decode_fri_parameters(&fri_parameters), ); + let results = match check_shard_batch( + &toplevel, + fun_idx, + env, + &shards, + use_bytecode, + jobs, + &system, + max_ram_bytes, + false, + ) { + Ok(results) => results, + Err(error) => return LeanExcept::error_string(&error), + }; + let arr = LeanArray::alloc(results.len()); + for (i, result) in results.iter().enumerate() { + let row = LeanAiurShardResult::alloc(0); + row.set_obj(0, LeanString::new(&result.error)); + row.set_obj(1, LeanOwned::box_usize(result.peak_bytes)); + row.set_obj(2, LeanOwned::box_usize(result.suggested_parts)); + arr.set(i, row); + } + LeanExcept::ok(arr) +} + +pub(super) struct ShardCheckResult { + pub error: String, + pub peak_bytes: usize, + pub suggested_parts: usize, + /// Digest of the exact claim supplied to execution, retained for reports. + pub claim: Option, +} + +/// Shared executor for the legacy Lean wave driver and native whole-partition +/// setup. Witness construction, kernel dispatch, record lifetime, and the RAM +/// gate must stay identical across the two callers. +#[allow(clippy::cast_precision_loss)] +pub(super) fn check_shard_batch( + toplevel: &aiur::bytecode::Toplevel, + fun_idx: usize, + env: &ixon::Env, + shards: &[Vec], + use_bytecode: bool, + jobs: usize, + system: &AiurSystem, + max_ram_bytes: usize, + progress: bool, +) -> Result, String> { + use rayon::prelude::*; + use std::sync::atomic::{AtomicUsize, Ordering}; + let started = std::time::Instant::now(); + let completed = AtomicUsize::new(0); // RAM-gated admission: reserve each shard's estimated execution RSS // (fixed ingress cost + owned serialized bytes x measured slope) // against most of the RAM available at entry. Memory in flight — @@ -811,42 +862,69 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( max as f64 / gib, ); } - let check_batch = || -> Vec<(String, usize, usize)> { + let check_batch = || -> Vec { shards .par_iter() .zip(estimates.par_iter()) - .map(|(owned, est)| { + .enumerate() + .map(|(index, (owned, est))| { gate.acquire(*est); + if progress { + eprintln!( + "[ixvm_check] shard {index} started ({} consts)", + owned.len() + ); + } + let mut claim_digest = None; let result = match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( env, owned, ) { Err(e) => (format!("witness build: {e}"), 0, 1), - Ok((_claim, input, mut io_buffer)) => match dispatch_execute( - &toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) { - Err(e) => (e, 0, 1), - // Both reductions happen here, while the record is - // still owned by this task: it is dropped before - // `gate.release`, so admission keeps bounding peak RSS by - // the shards in flight rather than by the whole partition. - Ok((record, _output)) => { - let peak = system.peak_prove_bytes(&record).peak; - let parts = if max_ram_bytes > 0 && peak > max_ram_bytes { - system.suggested_split_parts(&record, max_ram_bytes) - } else { - 1 - }; - (String::new(), peak, parts) - }, + Ok((claim, input, mut io_buffer)) => { + let mut bytes = Vec::new(); + claim.put(&mut bytes); + claim_digest = Some(ix_common::address::Address::hash(&bytes)); + match dispatch_execute( + toplevel, + fun_idx, + input, + &mut io_buffer, + use_bytecode, + ) { + Err(e) => (e, 0, 1), + // Both reductions happen here, while the record is + // still owned by this task: it is dropped before + // `gate.release`, so admission keeps bounding peak RSS by + // the shards in flight rather than by the whole partition. + Ok((record, _output)) => { + let peak = system.peak_prove_bytes(&record).peak; + let parts = if max_ram_bytes > 0 && peak > max_ram_bytes { + system.suggested_split_parts(&record, max_ram_bytes) + } else { + 1 + }; + (String::new(), peak, parts) + }, + } }, }; gate.release(*est); - result + let done = completed.fetch_add(1, Ordering::Relaxed) + 1; + if progress { + eprintln!( + "[ixvm_check] {done}/{} shards, {:.1}s: shard {index} {}", + shards.len(), + started.elapsed().as_secs_f64(), + if result.0.is_empty() { "ok" } else { &result.0 }, + ); + } + ShardCheckResult { + error: result.0, + peak_bytes: result.1, + suggested_parts: result.2, + claim: claim_digest, + } }) .collect() }; @@ -856,20 +934,12 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( let pool = match rayon::ThreadPoolBuilder::new().num_threads(jobs).build() { Ok(p) => p, Err(e) => { - return LeanExcept::error_string(&format!("rayon pool: {e}")); + return Err(format!("rayon pool: {e}")); }, }; pool.install(check_batch) }; - let arr = LeanArray::alloc(results.len()); - for (i, (err, peak, parts)) in results.iter().enumerate() { - let row = LeanAiurShardResult::alloc(0); - row.set_obj(0, LeanString::new(err)); - row.set_obj(1, LeanOwned::box_usize(*peak)); - row.set_obj(2, LeanOwned::box_usize(*parts)); - arr.set(i, row); - } - LeanExcept::ok(arr) + Ok(results) } /// `Bytecode.Toplevel.shardCheckWithEnv`: per-shard check against a @@ -1623,7 +1693,7 @@ fn build_lean_io_map(io_buffer: &IOBuffer) -> LeanArray { arr } -fn decode_commitment_parameters( +pub(super) fn decode_commitment_parameters( obj: &LeanAiurCommitmentParameters, ) -> CommitmentParameters { let ctor = obj.as_ctor(); @@ -1633,7 +1703,7 @@ fn decode_commitment_parameters( } } -fn decode_fri_parameters( +pub(super) fn decode_fri_parameters( obj: &LeanAiurFriParameters, ) -> FriParameters { let ctor = obj.as_ctor(); diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index cf4ab2645..a3a52721f 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -297,6 +297,8 @@ lean_ffi::lean_inductive! { LeanAiurProveEnvResult [ { num_obj: 4 } ]; // error, peakBytes, suggestedParts LeanAiurShardResult [ { num_obj: 3 } ]; + // constants, shards, failures, elapsedMs + LeanAiurPartitionCheckResult [ { num_obj: 4 } ]; // claimBytes, proof, peakBytes, suggestedParts LeanAiurShardProveResult [ { num_obj: 4 } ]; // claimBytes, constantCount diff --git a/crates/kernel/src/shard.rs b/crates/kernel/src/shard.rs index 3a21a6480..ef20038c2 100644 --- a/crates/kernel/src/shard.rs +++ b/crates/kernel/src/shard.rs @@ -1551,13 +1551,22 @@ impl ShardManifest { } let total_cross_ingress = c.u128()?; let num_shards = c.u32()? as usize; + // Even an empty shard needs 37 bytes. Validate before allocating from + // an untrusted count, including on the native execution startup path. + if num_shards > (c.buf.len() - c.pos) / 37 { + return Err("truncated .ixes shard table".into()); + } let mut shards = Vec::with_capacity(num_shards); for _ in 0..num_shards { let id = c.u32()?; let heartbeats = c.u64()?; let own_size = c.u64()?; let cross_ingress = c.u64()?; - let assumption_root = if c.u8()? == 1 { Some(c.addr()?) } else { None }; + let assumption_root = match c.u8()? { + 0 => None, + 1 => Some(c.addr()?), + tag => return Err(format!("invalid .ixes assumption-root tag {tag}")), + }; let blocks = c.addrs()?; let foreign_blocks = c.addrs()?; shards.push(ShardInfo { @@ -1574,16 +1583,29 @@ impl ShardManifest { // Optional trailing tree section. Absent (end-of-input) on pre-tree // manifests, or an explicit `0` presence byte. let tree = if c.pos < c.buf.len() { - if c.u8()? == 1 { Some(AggNode::get(&mut c)?) } else { None } + match c.u8()? { + 0 => None, + 1 => Some(AggNode::get(&mut c)?), + tag => return Err(format!("invalid .ixes tree-presence tag {tag}")), + } } else { None }; // Optional trailing measured-peaks section; absent on older manifests. - if c.pos < c.buf.len() && c.u8()? == 1 { - for sh in &mut shards { - sh.measured_peak_bytes = c.u64()?; + if c.pos < c.buf.len() { + match c.u8()? { + 0 => {}, + 1 => { + for sh in &mut shards { + sh.measured_peak_bytes = c.u64()?; + } + }, + tag => return Err(format!("invalid .ixes measured-peaks tag {tag}")), } } + if c.pos != c.buf.len() { + return Err("trailing bytes after .ixes manifest".into()); + } // The tree is the aggregation plan: a leaf set that is not exactly the // shard id set (each id once) would silently drop or duplicate proven // shards in the fold, so a manifest carrying such a tree is invalid. @@ -1646,11 +1668,14 @@ impl<'a> Cur<'a> { } fn addrs(&mut self) -> Result, String> { let n = self.u32()? as usize; - let mut v = Vec::with_capacity(n); - for _ in 0..n { - v.push(self.addr()?); - } - Ok(v) + let len = n.checked_mul(32).ok_or(".ixes address count overflow")?; + self + .take(len)? + .as_chunks::<32>() + .0 + .iter() + .map(|bytes| Address::from_slice(bytes).map_err(|_| "bad address".into())) + .collect() } } From 1769b268c438c8d6652085a5ee7fceb4755a6b15 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Tue, 8 Sep 2026 08:22:38 -0400 Subject: [PATCH 2/3] perf(ixvm): reduce execution memory and refine shards incrementally --- Benchmarks/IxVM/FocusFailures.lean | 227 + Benchmarks/IxVM/README.md | 216 + Ix/Aiur/Protocol.lean | 72 +- Ix/Aiur/Stages/Codegen.lean | 82 +- Ix/Cli/CheckCmd.lean | 42 +- Ix/Cli/ProveCmd.lean | 13 +- Ix/IxVM/FunctionGroups.lean | 6 +- Ix/IxVM/Kernel/Klimbs.lean | 224 +- Ix/IxVM/Kernel/NatPrim.lean | 22 +- Ix/IxVM/Kernel/Subst.lean | 102 +- Tests/Cli/NativePartition.lean | 213 +- Tests/Ix/IxVM.lean | 170 +- Tests/Ix/IxVM/ByteHints.lean | 173 + Tests/Ix/IxVM/CarryAdd.lean | 159 + Tests/Ix/IxVM/FusedMul.lean | 238 + Tests/Ix/IxVM/LimbMul.lean | 283 + Tests/Ix/IxVM/SubstProjection.lean | 337 + Tests/Main.lean | 17 +- crates/aiur/src/execute.rs | 524 +- crates/aiur/src/execute/budget.rs | 141 + crates/aiur/src/execute/budget/tests.rs | 181 + crates/aiur/src/execute/byte_tests.rs | 225 + crates/aiur/src/execute/stats.rs | 181 + crates/aiur/src/gadgets.rs | 7 +- crates/aiur/src/gadgets/bytes1.rs | 40 +- crates/aiur/src/gadgets/bytes2.rs | 95 +- crates/aiur/src/memory.rs | 14 +- crates/aiur/src/querymap.rs | 477 +- crates/aiur/src/querymap/multiplicity.rs | 202 + .../aiur/src/querymap/multiplicity/tests.rs | 259 + crates/aiur/src/querymap/stats.rs | 232 + crates/aiur/src/querymap/storage.rs | 439 + crates/aiur/src/querymap/tests.rs | 610 + crates/aiur/src/synthesis.rs | 239 +- crates/aiur/src/trace.rs | 76 +- crates/ffi/src/aiur.rs | 2 + crates/ffi/src/aiur/admission.rs | 537 + crates/ffi/src/aiur/admission/dispatch.rs | 120 + .../ffi/src/aiur/admission/dispatch/tests.rs | 385 + crates/ffi/src/aiur/admission/tests.rs | 394 + crates/ffi/src/aiur/aggregate.rs | 3 + crates/ffi/src/aiur/check.rs | 189 +- crates/ffi/src/aiur/check/refine.rs | 275 + crates/ffi/src/aiur/check/refine/tests.rs | 373 + crates/ffi/src/aiur/check/tests.rs | 101 +- crates/ffi/src/aiur/memory.rs | 251 + crates/ffi/src/aiur/memory/tests.rs | 177 + crates/ffi/src/aiur/protocol.rs | 621 +- crates/ffi/src/lean.rs | 4 +- crates/ixvm-codegen/src/aiur_ix_aggr.rs | 10549 ++-- .../ixvm-codegen/src/aiur_ix_aggr_runner.rs | 4 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 41662 ++++++++-------- crates/ixvm-codegen/src/aiur_ixvm_runner.rs | 20 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 10786 ++-- .../src/aiur_multi_stark_runner.rs | 4 +- lakefile.lean | 4 + 56 files changed, 41536 insertions(+), 31463 deletions(-) create mode 100644 Benchmarks/IxVM/FocusFailures.lean create mode 100644 Benchmarks/IxVM/README.md create mode 100644 Tests/Ix/IxVM/ByteHints.lean create mode 100644 Tests/Ix/IxVM/CarryAdd.lean create mode 100644 Tests/Ix/IxVM/FusedMul.lean create mode 100644 Tests/Ix/IxVM/LimbMul.lean create mode 100644 Tests/Ix/IxVM/SubstProjection.lean create mode 100644 crates/aiur/src/execute/budget.rs create mode 100644 crates/aiur/src/execute/budget/tests.rs create mode 100644 crates/aiur/src/execute/byte_tests.rs create mode 100644 crates/aiur/src/execute/stats.rs create mode 100644 crates/aiur/src/querymap/multiplicity.rs create mode 100644 crates/aiur/src/querymap/multiplicity/tests.rs create mode 100644 crates/aiur/src/querymap/stats.rs create mode 100644 crates/aiur/src/querymap/storage.rs create mode 100644 crates/aiur/src/querymap/tests.rs create mode 100644 crates/ffi/src/aiur/admission.rs create mode 100644 crates/ffi/src/aiur/admission/dispatch.rs create mode 100644 crates/ffi/src/aiur/admission/dispatch/tests.rs create mode 100644 crates/ffi/src/aiur/admission/tests.rs create mode 100644 crates/ffi/src/aiur/check/refine.rs create mode 100644 crates/ffi/src/aiur/check/refine/tests.rs create mode 100644 crates/ffi/src/aiur/memory.rs create mode 100644 crates/ffi/src/aiur/memory/tests.rs diff --git a/Benchmarks/IxVM/FocusFailures.lean b/Benchmarks/IxVM/FocusFailures.lean new file mode 100644 index 000000000..69cd893c0 --- /dev/null +++ b/Benchmarks/IxVM/FocusFailures.lean @@ -0,0 +1,227 @@ +import Ix.Cli.CheckCmd + +/-! +Prepare, but do not execute, a focused ixVM regression partition from an +ix-refine/0 report's failed singleton blocks. The full partition is preserved; +the normal native check path still validates the whole environment's coverage. +This is a diagnostic selection, not a certificate that skipped blocks pass. +-/ +open Lean System + +namespace Benchmarks.IxVM.FocusFailures + +structure Target where + sourceShard : Nat + block : Address + label : String + reason : String + deriving Inhabited + +def failedTargets (report : Json) : Except String (Array Target) := do + unless (← report.getObjValAs? String "schema") == "ix-refine/0" do + throw "expected an ix-refine/0 report" + let leaves ← report.getObjValAs? (Array Json) "leaves" + let mut targets := #[] + let mut seen : Std.HashSet Address := {} + let mut leafIds : Std.HashSet Nat := {} + for leaf in leaves do + let id ← leaf.getObjValAs? Nat "id" + if leafIds.contains id then throw s!"duplicate report leaf {id}" + leafIds := leafIds.insert id + if (← leaf.getObjValAs? String "status") != "failed" then continue + let before := targets.size + for part in ← leaf.getObjValAs? (Array Json) "parts" do + if (← part.getObjValAs? String "status") != "failed" then continue + let blocks ← part.getObjValAs? (Array String) "blocks" + unless blocks.size == 1 do + throw s!"leaf {id}: expected a failed singleton block, got {blocks.size}" + let some block := Address.fromString blocks[0]! | throw "invalid block address" + if seen.contains block then throw s!"duplicate failed block {block}" + seen := seen.insert block + let label ← part.getObjValAs? String "label" + let reason ← part.getObjValAs? String "reason" + targets := targets.push { sourceShard := id, block := block, label := label, reason := reason } + if targets.size == before then throw s!"failed leaf {id} has no failed singleton parts" + if targets.isEmpty then throw "report contains no failed singleton blocks" + return targets + +/-- Remainder first, then failed singletons in report order. No measured peak +is carried to a different partition or executor revision. -/ +def refinements (shards : Array (Array Address)) (targets : Array Target) : + Except String (Array Ix.Cli.CheckCmd.LeafRefinement) := do + let mut grouped : Std.HashMap Nat (Array Address) := {} + for target in targets do + let some blocks := shards[target.sourceShard]? | throw "source shard is out of range" + unless blocks.contains target.block do + throw s!"failed block {target.block} does not belong to source shard {target.sourceShard}" + let previous := grouped[target.sourceShard]?.getD #[] + if previous.contains target.block then throw "duplicate selection" + grouped := grouped.insert target.sourceShard (previous.push target.block) + let mut result := #[] + for id in (grouped.toArray.map (·.1)).qsort (· < ·) do + let selected := grouped[id]!.toList + let remainder := shards[id]!.filter (!selected.contains ·) + let singletons := selected.toArray.map fun block => (#[block], 0) + let parts := (if remainder.isEmpty then #[] else #[(remainder, 0)]) ++ singletons + -- An already-singleton source leaf needs no refinement. + if parts.size > 1 then result := result.push { shard := id, parts } + return result + +def selectedIds (shards : Array (Array Address)) (targets : Array Target) : + Except String (Array Nat) := do + let mut ids := #[] + for target in targets do + let owners := (shards.mapIdx fun id blocks => (id, blocks)).filter + fun (_, blocks) => blocks.contains target.block + unless owners.size == 1 && owners[0]!.2 == #[target.block] do + throw s!"refined manifest does not uniquely isolate {target.block}" + ids := ids.push owners[0]!.1 + return ids + +def prepare (ixe source reportPath out : FilePath) : IO (Array Nat) := do + let sidecar := FilePath.mk (out.toString ++ ".focus.json") + if (← out.pathExists) || (← sidecar.pathExists) then + throw <| IO.userError "output or focus sidecar already exists; choose a fresh path" + let report ← IO.ofExcept (Json.parse (← IO.FS.readFile reportPath)) + let targets ← IO.ofExcept (failedTargets report) + let bytes ← IO.FS.readBinFile source + let provenance ← IO.ofExcept (report.getObjVal? "source") + let expected ← IO.ofExcept (provenance.getObjValAs? String "blake3") + unless toString (Address.blake3 bytes) == expected do + throw <| IO.userError "source manifest digest does not match the failure report" + let environment ← IO.ofExcept (report.getObjVal? "env") + let expectedEnv ← IO.ofExcept (environment.getObjValAs? String "path") + unless (← IO.FS.realPath ixe) == (← IO.FS.realPath expectedEnv) do + throw <| IO.userError "environment path does not match the failure report" + let expectedBytes ← IO.ofExcept (environment.getObjValAs? Nat "bytes") + unless (← ixe.metadata).byteSize.toNat == expectedBytes do + throw <| IO.userError "environment size does not match the failure report" + let view ← IO.ofExcept (Ix.Cli.CheckCmd.parseIxesManifest bytes) + let cuts ← IO.ofExcept (refinements view.shards targets) + IO.println s!"[ixvm-focus] isolating {targets.size} failed blocks; retaining all {view.shards.size} source leaves" + -- Zero-copy mmap and native static-profile/refinement logic. No Lean env + -- decoding, checking of passed constants, or fabricated partial manifest. + let handle ← IO.ofExcept (Aiur.EnvHandle.fromIxe ixe.toString) + let _ ← Aiur.shardManifestRefine handle source.toString + (Ix.Cli.CheckCmd.refinementsBlob cuts) ByteArray.empty out.toString + let focusedBytes ← IO.FS.readBinFile out + let focused ← IO.ofExcept (Ix.Cli.CheckCmd.parseIxesManifest focusedBytes) + let ids ← IO.ofExcept (selectedIds focused.shards targets) + let selections := (targets.zip ids).map fun (target, id) => Json.mkObj [ + ("id", toJson id), ("source_shard", toJson target.sourceShard), + ("block", toJson (toString target.block)), ("previous_label", toJson target.label), + ("previous_reason", toJson target.reason)] + let selection := String.intercalate "," (ids.toList.map toString) + IO.FS.writeFile sidecar <| (Json.mkObj [ + ("schema", toJson "ixvm-focus/0"), ("report", toJson reportPath.toString), + ("source_blake3", toJson expected), ("env", environment), + ("manifest", toJson out.toString), + ("manifest_blake3", toJson (toString (Address.blake3 focusedBytes))), + ("selection", toJson selection), ("targets", toJson selections), + ("scope", toJson "Diagnostic execution targets only; no previously passed claim is certified or reused.") + ]).pretty ++ "\n" + IO.println s!"[ixvm-focus] prepared {focused.shards.size} leaves; execute only --shards {selection}" + IO.println s!"[ixvm-focus] target provenance → {sidecar}" + return ids + +private def expect (p : Bool) (message : String) : IO Unit := + unless p do throw <| IO.userError message + +private def fixtureManifest (blocks : Array Address) : ByteArray := Id.run do + let mut bytes : ByteArray := ⟨#[0x49, 0x58, 0x45, 0x53, 0, 0, 0, 0] ++ Array.replicate 16 0⟩ + bytes := bytes ++ (1 : UInt32).toLEBytes ++ (0 : UInt32).toLEBytes + ++ ⟨Array.replicate 25 0⟩ ++ blocks.size.toUInt32.toLEBytes + for block in blocks do bytes := bytes ++ block.hash + return bytes ++ (0 : UInt32).toLEBytes ++ ⟨#[0, 0]⟩ + +private def roundtripTest : IO Unit := do + let dir ← IO.FS.createTempDir + try + let ixe := dir / "env.ixe" + let source := dir / "source.ixes" + let reportPath := dir / "report.json" + let out := dir / "focused.ixes" + let mut env : Ixon.Env := {} + let mut addresses := #[] + for n in [:3] do + let c : Ixon.Constant := ⟨.axio ⟨false, n.toUInt64, .sort 0⟩, #[], #[], #[.succ .zero]⟩ + let addr := Address.blake3 (Ixon.serConstant c) + addresses := addresses.push addr + env := env.storeConst addr c + let envBytes ← IO.ofExcept (Ixon.serEnv env) + let sourceBytes := fixtureManifest addresses + IO.FS.writeBinFile ixe envBytes + IO.FS.writeBinFile source sourceBytes + let parts := (addresses.extract 1 3).map fun block => Json.mkObj [ + ("status", toJson "failed"), ("blocks", toJson #[toString block]), + ("label", toJson "0.test"), ("reason", toJson "test memory limit")] + let report := Json.mkObj [("schema", toJson "ix-refine/0"), + ("env", Json.mkObj [("path", toJson ixe.toString), ("bytes", toJson envBytes.size)]), + ("source", Json.mkObj [("blake3", toJson (toString (Address.blake3 sourceBytes)))]), + ("leaves", toJson #[Json.mkObj [("id", toJson (0 : Nat)), + ("status", toJson "failed"), ("parts", toJson parts)]])] + IO.FS.writeFile reportPath report.compress + let ids ← prepare ixe source reportPath out + expect (ids == #[1, 2]) "native refinement returned wrong target ids" + let focused ← IO.ofExcept (Ix.Cli.CheckCmd.parseIxesManifest (← IO.FS.readBinFile out)) + expect (focused.shards == addresses.map (#[·])) "refinement changed the full partition" + expect (focused.aggregationTree.leaves.toList.mergeSort == [0, 1, 2]) + "refined aggregation tree lost or repeated a leaf" + let vm ← IO.ofExcept IxVM.ixVM + let compiled ← IO.ofExcept vm.compile + let result ← IO.ofExcept (← compiled.bytecode.checkPartition + (compiled.getFuncIdx `verify_claim |>.get!) ixe.toString out.toString + 1 false Aiur.defaultCommitmentParameters Aiur.defaultFriParameters + (dir / "execution.json").toString "test" "focus roundtrip" "none" (some ids)) + expect (result.constants == 2 && result.shards == 2 && result.failures == 0) + "focused execution ran the wrong targets or failed" + let audit ← IO.ofExcept (Json.parse (← IO.FS.readFile (dir / "execution.json"))) + let leaves ← IO.ofExcept (audit.getObjValAs? (Array Json) "leaves") + expect ((← IO.ofExcept (leaves[0]!.getObjValAs? String "status")) == "unchanged") + "unselected constant was reported checked" + let refused ← try let _ ← prepare ixe source reportPath out; pure false catch _ => pure true + expect refused "existing output was overwritten" + finally + IO.FS.removeDirAll dir + +def selfTest : IO Unit := do + let a := Address.blake3 "a".toUTF8 + let b := Address.blake3 "b".toUTF8 + let c := Address.blake3 "c".toUTF8 + let target : Target := { sourceShard := 1, block := b, label := "1.0", reason := "limit" } + let part := Json.mkObj [("status", toJson "failed"), ("blocks", toJson #[toString b]), + ("label", toJson "1.0"), ("reason", toJson "limit")] + let report := fun parts => Json.mkObj [("schema", toJson "ix-refine/0"), + ("leaves", toJson #[Json.mkObj [("id", toJson (1 : Nat)), + ("status", toJson "failed"), ("parts", toJson parts)]])] + expect ((← IO.ofExcept (failedTargets (report #[part]))).size == 1) "report selection" + expect (!(failedTargets (report #[part, part])).isOk) "duplicate failure accepted" + expect (!(failedTargets (report (#[] : Array Json))).isOk) "empty failure accepted" + let cuts ← IO.ofExcept (refinements #[#[a], #[b, c]] #[target]) + let some cut := cuts[0]? | throw <| IO.userError "missing refinement" + expect (cuts.size == 1 && cut.shard == 1 && + cut.parts == #[(#[c], 0), (#[b], 0)]) "failed block not isolated" + expect ((← IO.ofExcept (selectedIds #[#[a], #[c], #[b]] #[target])) == #[2]) + "selection confused original and refined ids" + expect (!(selectedIds #[#[a], #[b, c]] #[target]).isOk) "non-singleton accepted" + expect (!(selectedIds #[#[b], #[b]] #[target]).isOk) "duplicate ownership accepted" + expect (!(refinements #[#[a], #[c]] #[target]).isOk) "wrong owner accepted" + expect (!(refinements #[#[a]] #[target]).isOk) "out-of-range owner accepted" + expect ((← IO.ofExcept (refinements #[#[a], #[b]] #[target])).isEmpty) + "already singleton needlessly refined" + roundtripTest + IO.println "[ixvm-focus] selection and native refinement/execution tests passed" + +end Benchmarks.IxVM.FocusFailures + +def main (args : List String) : IO UInt32 := do + try + match args with + | ["--self-test"] => Benchmarks.IxVM.FocusFailures.selfTest; return 0 + | [ixe, source, report, out] => + let _ ← Benchmarks.IxVM.FocusFailures.prepare ixe source report out + return 0 + | _ => + IO.eprintln "usage: bench-ixvm-focus ENV.ixe SOURCE.ixes REPORT.json FOCUSED.ixes\n bench-ixvm-focus --self-test" + return 1 + catch e => IO.eprintln s!"[ixvm-focus] {e}"; return 1 diff --git a/Benchmarks/IxVM/README.md b/Benchmarks/IxVM/README.md new file mode 100644 index 000000000..261840aca --- /dev/null +++ b/Benchmarks/IxVM/README.md @@ -0,0 +1,216 @@ +# Focused ixVM execution regressions + +`bench-ixvm-focus` isolates a completed `ix-refine/0` report's failed singleton +**blocks**, including all projections of a mutual block. It prepares a full +refined manifest; it does not execute anything or claim that skipped constants +have passed. A useful regression loop is to prepare once, then reuse this +manifest and selection across frozen executor binaries. + +```sh +lake build bench-ixvm-focus +lake exe bench-ixvm-focus --self-test +lake exe bench-ixvm-focus ENV.ixe ORIGINAL.ixes OLD-FAILURES.json FOCUSED.ixes +# Use the selection printed by the preceding command: +IX_AIUR_EXEC_MAX_BYTES=137438953472 \ + lake exe ix check --ixe ENV.ixe --ixes FOCUSED.ixes \ + --shards SELECTED_IDS --jobs 1 --keep-going --report focused-report.json +``` + +Use fresh output paths. The helper checks the source-manifest digest, environment +path/size, singleton membership and uniqueness. Existing Rust refinement +recomputes the partition metadata and aggregation tree, and checks complete, +disjoint block coverage. The execution command still runs native whole-env +content-address/ownership validation before checking only the selected leaves. +Dependencies remain available as the normal shard frontier. Unselected leaves +are reported `unchanged`, not checked or proven. This is a diagnostic test, not +a substitute for a subsequent full-partition execution or proof run. + +Native coverage/ownership setup uses its own temporary pool (up to 8 available +CPUs by default), even with `--jobs 1` or `RAYON_NUM_THREADS=1`. Set +`IX_AIUR_SETUP_THREADS` to a positive count to override setup parallelism. +The setup pool is dropped before creating the execution pool; `--jobs` still +controls the number of execution workers. This changes neither validation nor +which leaves execute. + +`FOCUSED.ixes.focus.json` records exact target block addresses, original labels +and failure reasons, source/refined manifest hashes, and the reusable selection. +The report must contain completed singleton failures: a still-running parent or +an incomplete split report is not a valid input. Memory-budget failures are +resource limits, not kernel rejections. An already passing report has no targets; +reuse the earlier failure report to retain historically expensive regressions. + +For the Anthropic FLT campaign, the historical report is +`ixvm-shard504-carry-add.y9PfMu/report.json`: 270/274 constants passed and four +singleton blocks hit 32 GiB. The subsequent byte-packed 128 GiB baseline +`ixvm-shard504-compact128.K21HOd` passed all 274 via three final parts in +48m 36.5s. Those four blocks remain the focused optimization regression set; +they are no longer unresolved execution failures. + +Keep an OS/cgroup memory cap and wall-clock deadline in addition to the record +limit. The record limit measures accounted execution storage, not total RSS or +the much larger analytic peak of a future STARK proof. No proof is generated by +these execution tests. + +## Completion-driven execution refinement + +Native full/selected partition checks use one completion queue, execution pool, +admission controller and shared record budget for the entire check. A parent +that hits its own record limit releases its record and permit before its two +children are queued; it no longer waits for every other original shard to +finish. Splitting still occurs only between whole blocks, including their +mutual projections. Children join the FIFO ready queue; fit-aware backfilling +and larger tail-tier grants are separate, unimplemented policies. + +A shared-budget failure is different: admission pauses until current attempts +drain, then retries that unchanged claim, with the existing maximum of two +pressure retries. It does not split merely because peers consumed the shared +budget. A still-oversized singleton and an ordinary kernel rejection remain +failures. No running record is suspended, resumed, or given a larger limit. + +Admission and completion waits stay outside Rayon, leaving workers available +for nested witness work. Active tasks plus unconsumed completion messages are +bounded by pool width. The dispatcher drains all launched work on an error; +it never returns partial success. Under unwind builds, worker panics become +dispatcher errors after cleanup; panic-abort and OOM still terminate the process. +Live headroom, growth forecasts, recovery delays and record limits remain in +force, including the serial fallback when telemetry is unavailable. + +Admission diagnostics report the backoff reason, full memory-PSI sample and +ten-second trend, swap growth and remaining recovery delay. A brief >10% PSI +sample pauses admission immediately and reduces concurrency, but does not +restart the five-second cooldown by itself: recurring short system-wide spikes +must not starve otherwise well-provisioned serial work. Sustained >10% PSI +(`full avg10`), process swap growth and insufficient live headroom still require +recovery. Every new shard must still fit the live reserve, outstanding +reservations and growth forecast. A 30-second idle timeout reports the actual +reason and next reservation; it does not silently bypass the gate or declare +partial coverage successful. See [Linux PSI](https://docs.kernel.org/accounting/psi.html) +for the distinction between short stall samples and the average trend. + +Progress identifies each shard label, pressure-attempt number and generation. +The `N/M shards settled` counter refers to original selected shards: a split +parent settles only after all descendants finish. Settled can include failures; +use the final report, not the progress fraction, to determine success. + +Native audit reports include `scheduler: "completion-driven"`, `executed` +(all attempts), and `max_generation` (maximum split/retry lineage length). +`waves` is `null` because this path has no batch-wave barriers. Final child +labels and ownership are sorted deterministically, regardless of completion +order. Unselected leaves remain `unchanged`; an aborted parent's predicted +proof peak is not fabricated from its children's peaks. Paths that still need +the legacy Lean driver, such as destination-prover-budget refinement, retain +that driver and its numeric wave count. + +## Compact multiplicity prototype + +Set `IX_AIUR_COMPACT_MULTIPLICITIES=1` to retain function and memory-query +counters in `u32` segments. The default remains full-field storage while we +compare throughput and memory on focused FLT and ordinary workloads. The flag +is read once per process; use separate invocations for on/off comparisons. + +Counters still have field semantics: a larger initial value or a hit past +`u32::MAX` widens only that segment to full fields, without truncation, +saturation, or changes to query order, memory pointers, hint promotion, or +witnesses. New segments may start narrow again. A widened segment stays wide +after field wrap. Widening reserves both old and replacement storage before +copying; refusal is a typed resource limit, even on a memo hit, and leaves +that map's rows and encoding unchanged. It is not a successful check or a +resumable partial record. This does not change scheduling or shard limits. + +Use the same input, manifest, selection, limits, and worker counts for each +comparison; leave profiling disabled for clean execution timings: + +```sh +IX_AIUR_COMPACT_MULTIPLICITIES=1 IX_AIUR_EXEC_MAX_BYTES=137438953472 \ + lake exe ix check --ixe ENV.ixe --ixes FOCUSED.ixes \ + --shards SELECTED_IDS --jobs 1 --keep-going --report compact-report.json +``` + +## Ordinary and Mathlib controls + +Reuse a current-format Mathlib environment to extract small dependency closures +with the native CLI; this does not rebuild Mathlib or modify the source `.ixe`: + +```sh +lake exe ix shard extract MATHLIB.ixe \ + --consts Nat.add_comm,List.map_map --out CORE.ixe +lake exe ix shard extract MATHLIB.ixe \ + --consts Nat.exists_infinite_primes --out PRIME.ixe +lake exe ix shard CORE.ixe --shards 1 --out CORE.ixes +lake exe ix shard PRIME.ixe --shards 1 --out PRIME.ixes +``` + +Use fresh output paths. Extraction preserves dependency closure and whole mutual +blocks. An incompatible older `.ixe` needs recompilation or replacement with a +compatible artifact; changing its header is not a format conversion. Extraction +from the full environment can itself require substantial RAM, so finish it before +starting timed execution comparisons. + +Then compare separate invocations with compact counters disabled/enabled, using +the same frozen binary, fixtures, manifests, limits and worker counts: + +```sh +IX_AIUR_COMPACT_MULTIPLICITIES=1 IX_AIUR_MULTIPLICITY_STATS=0 \ + IX_AIUR_SETUP_THREADS=2 IX_AIUR_EXEC_MAX_BYTES=8589934592 \ + RAYON_NUM_THREADS=1 LEAN_NUM_THREADS=1 \ + ./FROZEN-IX check --ixe PRIME.ixe --ixes PRIME.ixes --jobs 1 \ + --report PRIME-compact-report.json --json PRIME-compact-results.json +``` + +Unset `IX_AIUR_QUERY_STATS` for clean timings too. Repeat in alternating order, +including the pre-change binary when available. Check exit status, zero failures, +complete ownership, claim equality, and unchanged predicted proof cost; do not +infer these from timing output alone. Keep final profiling scans separate from +timing controls, and distinguish encoded counter payload from peak RSS. Tiny +fixtures can be dominated by startup and allocation noise. These controls execute +only the extracted closures, not full Mathlib or a STARK proof. + +## Multiplicity-storage diagnostics + +Use `IX_AIUR_MULTIPLICITY_STATS=1` on a focused run to scan multiplicity +storage at execution return or rejection. Both generated Rust and bytecode +execution support it (also the generated recursive verifier and aggregator). +Leave it unset for timings used to compare executor optimizations. + +```sh +IX_AIUR_MULTIPLICITY_STATS=1 IX_AIUR_EXEC_MAX_BYTES=137438953472 \ + lake exe ix check --ixe ENV.ixe --ixes FOCUSED.ixes \ + --shards SELECTED_IDS --jobs 1 --keep-going --report profile-report.json +``` + +The `[aiur-multiplicity]` stderr records contain totals for all function and +memory maps, plus at most the 32 largest maps by counter-row count. Temporary +storage is proportional to the number of maps, not the number of query rows; +the linear scan reads only initialized counters and never runs on progress +ticks. `scan_us` reports its cost. Separate these profiled timings from clean +runs; scanning a large record still takes time and reads memory. + +- `counts`: disjoint canonical multiplicity bins, in order: 0, 1, 2–255, + 256–65535, 65536–u32::MAX, and larger. +- `segment_maxima` / `segment_rows`: segments / initialized rows whose + current maximum needs 1, 2, 4, or 8 bytes, in that order. This exposes the + widening impact of a rare large count in an otherwise small-count segment. +- `full_payload_bytes`: equivalent eight-byte counter payload, excluding page + rounding, spare capacity, and other table storage. +- `adaptive_payload_lower_bound` / `u32_payload_lower_bound`: hypothetical + segment-wide encodings of the snapshot, not measured allocations or RSS + savings. They omit allocation overhead and historical widening before a + field wrap. These remain estimates even with compact storage enabled. +- `stored_payload_bytes` / `stored_segments_u32_field`: actual initialized + encoded payload / segment counts in u32 and full-field form. Unlike the + snapshot lower bounds, these include segments kept wide after field wrap. + Payload excludes unused capacity, page rounding, and allocation metadata; + it is not the record's accounted allocation or process RSS. +- `canonical_sum`: sum of current canonical field values, not a lifetime + call/update count. Initialization, unconstrained hints, and field wrap matter. +- For budgeted execution, `accounted_bytes`, `reservation_peak_bytes`, and + `record_limit_bytes` describe the whole record's accounting, not its RSS or + predicted prover peak. The reservation peak includes transient charges and + local reservations rolled back when the shared budget refused them. + +`status=returned` means execution returned, not that a STARK proof was made. +`resource-limit` / `rejected` profiles describe partial, unsuccessful records. +Failure before a record is constructed cannot supply a counter snapshot. +The diagnostic is read-only: it does not alter grants, filtering, refinement, +query semantics, or which claims must pass. It is intended to guide compact +counter experiments, not to serve as an admission bound. diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index cbf933cc2..997d3c8f6 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -254,7 +254,8 @@ def proveAddrWithEnv (system : @& AiurSystem) projects will fit the budget (`AiurSystem::suggested_split_parts`). - `proof` is `none` exactly when the peak exceeded the budget — a + `proof` is `none` for measurement-only execution, an oversized prover + peak, or an early execution-memory interruption. Oversize is a RESULT rather than an error, since the caller's answer is to cut the shard into `suggestedParts` parts and prove those. The count is computed Rust-side because only there does the executed record @@ -264,6 +265,10 @@ def proveAddrWithEnv (system : @& AiurSystem) whenever the prove ran. The claim bytes are filled either way (the claim is known before proving starts). + Early execution-memory interruption returns `peakBytes = 0` (unknown, + NOT a measured zero-byte peak) and `suggestedParts = 2`, so neither + prove nor exec-only callers can accept the interrupted parent. + The final IO buffer is not returned — it is the shard's whole ingested byte scope and no caller reads it. -/ structure ShardProveResult where @@ -275,19 +280,20 @@ structure ShardProveResult where @[extern "rs_aiur_system_shard_prove_with_env"] private opaque shardProveWithEnv' : @& AiurSystem → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → @& Nat → Bool → - Except String ShardProveResult + IO (Except String ShardProveResult) /-- Per-shard prove against a Rust-owned `EnvHandle`: ONE execution, whose record is proven from directly. `maxRamBytes` is a per-shard prover-RAM budget checked against that record's projected peak before the witness phase begins; `0` means - detect (85% of `MemAvailable`, the policy the check batch's RAM gate - uses), and an unreadable `/proc/meminfo` disables the check rather - than guessing. Over budget, the record is dropped and `proof` is + detect (85% of cgroup-aware available memory). A separate cooperative + execution-storage limit can abort before the record completes. Over + the prover budget, the record is dropped and `proof` is `none` — learning that here costs one execution instead of an OOM part-way through an FFT. The peak comes back either way, so a prove - run yields the same split/merge signal a check run does. + run yields the same split/merge signal a check run does. Early execution + interruption instead returns an unknown peak (0) and a split request. `execOnly` stops after execution + measurement (`proof` is `none` either way; `suggestedParts` is 1 exactly when the peak fits): the @@ -296,7 +302,7 @@ def shardProveWithEnv (system : @& AiurSystem) (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) (maxRamBytes : Nat := 0) (execOnly : Bool := false) : - Except String ShardProveResult := + IO (Except String ShardProveResult) := shardProveWithEnv' system funIdx envHandle ownedBlob maxRamBytes execOnly @[extern "rs_aiur_system_verify"] @@ -346,18 +352,18 @@ opaque shardManifestRefine : @& EnvHandle → @& String → @[extern "rs_aiur_detected_ram_budget"] private opaque detectedRamBudgetFFI : IO UInt64 -/-- The prover/execution RAM budget the Rust side detects on this machine: - 85 % of `MemAvailable` (`ix_kernel::shard::RAM_USABLE_FRAC`) — the policy - the check batch's RAM gate and `ix prove --max-ram 0` use. `0` when - `/proc/meminfo` is unreadable; callers that need a budget fail closed - on it instead of running ungated. -/ +/-- The one-shot prover RAM budget: 85 % of the minimum of host available + RAM and visible cgroup headroom (including existing charges). + Returns `0` when telemetry is unavailable. Shard-batch execution uses + a separate live admission controller with additional growth headroom. -/ def detectedRamBudgetBytes : IO Nat := do pure (← detectedRamBudgetFFI).toNat namespace Bytecode.Toplevel -/-- Small result of whole-partition native orchestration. The environment, -manifest, per-constant ownership, witness data, and audit remain Rust-owned. -/ +/-- Small result of native partition orchestration. Counts describe only the +selected source shards and their owned constants (all shards without a +selection). The environment, ownership, witness data and audit stay in Rust. -/ structure PartitionCheckResult where constants : Nat shards : Nat @@ -365,9 +371,12 @@ structure PartitionCheckResult where elapsedMs : Nat deriving Inhabited -/-- Full-partition execution without a refinement budget, shard selection, or -proof-cache reuse. Rust memory-maps the input, validates and assigns every -constant in one pass, then invokes the same shard executor as the wave API. +/-- Partition execution without a destination prover budget or proof-cache +reuse. Rust memory-maps the input, validates and assigns EVERY constant in one +pass, then executes only the selected shards with the existing wave executor. +`none` selects all shards; `some #[]` is an error, never an all-shards fallback. +Ids are bounds-checked, sorted and deduplicated. Coverage/tree validation is +never restricted by the selection, and skipped leaves are not reported checked. An empty `report` string omits the audit file. File reads and report writes are sequenced through `IO`; this is not a pure function of the path strings. -/ @[extern "rs_aiur_check_partition"] @@ -375,7 +384,8 @@ opaque checkPartition (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (ixe manifest : @& String) (jobs : @& Nat) (useBytecode : Bool) (commitment : @& CommitmentParameters) (fri : @& FriParameters) - (report revision command budgetSource : @& String) : + (report revision command budgetSource : @& String) + (selection : @& Option (Array Nat) := none) : IO (Except String PartitionCheckResult) /-- One shard's result from `shardCheckBatchWithEnv`. -/ @@ -387,13 +397,18 @@ structure ShardResult where fit (`AiurSystem::suggested_split_parts`, measured on the record in-task). -/ suggestedParts : Nat + /-- 0 = execution finished (success or semantic error); 1 = interrupted at + the per-record memory limit (split and retry); 2 = interrupted at the + shared batch record limit (retry after this wave drains). An interrupted + execution always has a nonempty error and no measured prover peak. -/ + resourceStatus : Nat := 0 deriving Inhabited @[extern "rs_aiur_toplevel_shard_check_batch"] private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → @& Nat → @& CommitmentParameters → @& FriParameters → @& Nat → - Except String (Array ShardResult) + IO (Except String (Array ShardResult)) /-- Check EVERY shard of a partition in one call: rayon over the shard list with true work-stealing (no chunk barriers), each shard @@ -403,25 +418,28 @@ private opaque shardCheckBatchWithEnv' : @& Bytecode.Toplevel → Returns one `ShardResult` per shard in shard order: empty error = clean, and `peakBytes` is the analytic prover RAM peak ([`AiurSystem::peak_prove_bytes`] Rust-side) of the shard's executed - record — the split/merge input (0 on failure). - `jobs = 0` uses rayon's default pool width (all cores): peak RSS - is bounded by the Rust-side RAM gate (a byte-weighted admission - semaphore over estimated per-shard execution RSS vs available - system RAM), not by thread count — pass `jobs` only to narrow - CPU use. + record — the split/merge input (0 when no completed record is available). + `jobs = 0` uses rayon's default pool width (all cores). Live memory + admission controls concurrency, and cooperative allocation accounting + bounds per-record and aggregate query storage. Neither replaces the OS + memory cap: input/witness construction, stacks and allocator overhead + also consume memory. `IX_AIUR_EXEC_MAX_BYTES` overrides the per-record + accounted-storage limit (positive bytes; default at most 32 GiB). `maxRamBytes > 0` is a per-shard prover-RAM budget: each result's `suggestedParts` is 1 when its peak fits and the model's projected part count otherwise, so a caller can cut over-budget shards and re-batch the parts — the wave loop that audits a partition's split - behavior on executions alone. -/ + behavior on executions alone. Early execution limits instead return a + nonzero `resourceStatus`, a nonempty error and no measured peak. Callers + split/retry these outcomes even without a destination prover budget. -/ def shardCheckBatchWithEnv (toplevel : @& Bytecode.Toplevel) (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (shardsBlob : ByteArray) (useBytecode : Bool := false) (jobs : Nat := 0) (commitmentParameters : CommitmentParameters := defaultCommitmentParameters) (friParameters : FriParameters := defaultFriParameters) (maxRamBytes : Nat := 0) - : Except String (Array ShardResult) := + : IO (Except String (Array ShardResult)) := shardCheckBatchWithEnv' toplevel funIdx envHandle shardsBlob useBytecode jobs commitmentParameters friParameters maxRamBytes diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean index 4847e37b4..9cb102879 100644 --- a/Ix/Aiur/Stages/Codegen.lean +++ b/Ix/Aiur/Stages/Codegen.lean @@ -388,13 +388,12 @@ private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) let bumpStmt : String := if opUn then "" else - s!" if !unconstrained \{ record.function_queries[{callee}].bump_multiplicity(__i); }" - -- Skip `try_into().unwrap()` on the cache hit: we statically know - -- the cached output has exactly `OUT_{callee}` elements (only we - -- ever insert into this slot via the matching aiur_fn_{callee} - -- `Ctrl::Return`). An unchecked array copy is sound. + s!" if !unconstrained \{ record.function_queries[{callee}].bump_multiplicity(__i)?; }" + -- Decode directly into the fixed-size return array. The query store may + -- retain canonical bytes rather than full G values; never reinterpret + -- its storage as a G pointer. Full-width rows still use an array copy. let retExpr : String := - s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(record.function_queries[{callee}].output_at(__i).as_ptr() as *const [G; OUT_{callee}]) }; __ret" + s!" record.function_queries[{callee}].output_at(__i).to_array::()" -- A zero-multiplicity entry was computed only as an unconstrained -- hint; a constrained caller replays the body (constrained: `__cu` is -- false on that path) so promotion recurses through the whole @@ -405,11 +404,12 @@ private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) s!"__cu || record.function_queries[{callee}].mult_at(__i) != G::ZERO" let blockExpr : String := s!"\{ let __args: [G; IN_{callee}] = {argsStr};" ++ + s!" let __key = QueryKey::new(__args);" ++ s!" let __cu = {cuExpr};" ++ - s!" let __hit = record.function_queries[{callee}].get_index_of(&__args[..]);" ++ + s!" let __hit = record.function_queries[{callee}].get_prehashed(&__key);" ++ s!" match __hit \{ Some(__i) if {hitGuard} => \{" ++ bumpStmt ++ retExpr ++ " }," ++ - s!" _ => aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }" + s!" _ => aiur_fn_{callee}(__key, record, io_buffer, __cu)? } }" let mut stmts : Array RustStmt := #[ .letStmt false "__r_arr" (some s!"[G; OUT_{callee}]") (.lit blockExpr) ] @@ -424,13 +424,14 @@ private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt := let valsStr : String := (argsAsArray values).toStr let blockExpr : String := s!"\{ let __values: [G; {size}] = {valsStr};" ++ + s!" let __key = QueryKey::new(__values);" ++ s!" let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ - s!" if let Some(__i) = __mq.get_index_of(&__values[..]) \{" ++ - s!" if !unconstrained \{ __mq.bump_multiplicity(__i); }" ++ - s!" __mq.output_at(__i)[0]" ++ + s!" if let Some(__i) = __mq.get_prehashed(&__key) \{" ++ + s!" if !unconstrained \{ __mq.bump_multiplicity(__i)?; }" ++ + s!" __mq.output_at(__i).at(0)" ++ s!" } else \{" ++ s!" let __ptr = G::from_usize(__mq.len());" ++ - s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained));" ++ + s!" __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?;" ++ s!" __ptr } }" #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] @@ -442,9 +443,9 @@ private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt := s!" let __ptr_u64 = __v_{ptr}.as_canonical_u64();" ++ s!" let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?;" ++ s!" if __ptr_usize >= __mq.len() \{ return Err(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} }); }" ++ - s!" if !unconstrained \{ __mq.bump_multiplicity(__ptr_usize); }" ++ + s!" if !unconstrained \{ __mq.bump_multiplicity(__ptr_usize)?; }" ++ s!" let (__args, _) = __mq.get_index(__ptr_usize).expect(\"bounds checked above\");" ++ - s!" let __arr: [G; {size}] = __args[..{size}].try_into().unwrap(); __arr }" + s!" __args.to_array::<{size}>() }" let mut stmts : Array RustStmt := #[ .letStmt false "__loaded" (some s!"[G; {size}]") (.lit blockExpr) ] @@ -547,7 +548,7 @@ private def emitU8Bytes1 (out : Nat) (valueHelper : String) if outCount == 1 then let blockExpr : String := s!"if unconstrained \{ {unconShortcut}(&__v_{byte}) }" ++ - s!" else \{ {valueHelper}(__v_{byte}, record) }" + s!" else \{ {valueHelper}(__v_{byte}, record)? }" return #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] else -- BitDecomposition returns [G; 8]; the unconstrained shortcut @@ -555,7 +556,7 @@ private def emitU8Bytes1 (out : Nat) (valueHelper : String) -- Coerce its result into [G; outCount] for unified handling. let blockExpr : String := s!"if unconstrained \{ let __v: Vec = {unconShortcut}(&__v_{byte}); let __a: [G; {outCount}] = __v.try_into().unwrap(); __a }" ++ - s!" else \{ {valueHelper}(__v_{byte}, record) }" + s!" else \{ {valueHelper}(__v_{byte}, record)? }" let mut stmts : Array RustStmt := #[ .letStmt false "__b1_out" (some s!"[G; {outCount}]") (.lit blockExpr) ] @@ -569,14 +570,14 @@ private def emitU8Bytes2 (out : Nat) (valueHelper : String) Array RustStmt := Id.run do if outCount == 1 then let blockExpr : String := - s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ - s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }" + s!"if unconstrained \{ Bytes2::validate_inputs(&__v_{i}, &__v_{j})?; Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record)? }" return #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] else -- Multi-output byte operations. let blockExpr : String := - s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ - s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }" + s!"if unconstrained \{ Bytes2::validate_inputs(&__v_{i}, &__v_{j})?; Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record)? }" let tupTy : String := "(" ++ (String.intercalate ", " (List.replicate outCount "G")) ++ ")" let mut stmts : Array RustStmt := #[ @@ -588,12 +589,11 @@ private def emitU8Bytes2 (out : Nat) (valueHelper : String) /-- `Op::U8Add`: gadget bumps `bytes2_queries.add` and returns `(low, carry)`. Codegen now calls `bytes2_add_value` ONCE in - the constrained branch (vs the interpreter's two `Bytes2::add` - calls). -/ + the constrained branch, matching the interpreter. -/ private def emitU8Add (out : Nat) (i j : ValIdx) : Array RustStmt := let blockExpr : String := - s!"if unconstrained \{ Bytes2::add(&__v_{i}, &__v_{j}) }" ++ - s!" else \{ bytes2_add_value(__v_{i}, __v_{j}, record) }" + s!"if unconstrained \{ Bytes2::validate_inputs(&__v_{i}, &__v_{j})?; Bytes2::add(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ bytes2_add_value(__v_{i}, __v_{j}, record)? }" #[ .letStmt false "__b2_add" (some "(G, G)") (.lit blockExpr), declVal out (.field (.var "__b2_add") "0"), @@ -603,8 +603,8 @@ private def emitU8Add (out : Nat) (i j : ValIdx) : Array RustStmt := /-- `Op::U8Sub`: symmetric to U8Add. -/ private def emitU8Sub (out : Nat) (i j : ValIdx) : Array RustStmt := let blockExpr : String := - s!"if unconstrained \{ Bytes2::sub(&__v_{i}, &__v_{j}) }" ++ - s!" else \{ bytes2_sub_value(__v_{i}, __v_{j}, record) }" + s!"if unconstrained \{ Bytes2::validate_inputs(&__v_{i}, &__v_{j})?; Bytes2::sub(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ bytes2_sub_value(__v_{i}, __v_{j}, record)? }" #[ .letStmt false "__b2_sub" (some "(G, G)") (.lit blockExpr), declVal out (.field (.var "__b2_sub") "0"), @@ -626,12 +626,12 @@ private def emitU32LessThan (out : Nat) (x y : ValIdx) : Array RustStmt := s!" let __z_bytes = __b_u32.to_le_bytes();" ++ s!" let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1);" ++ s!" let __y_bytes = __c_u32.to_le_bytes();" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]));" ++ - s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?;" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?;" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?;" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?;" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?;" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?;" ++ s!" } __result }" #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] @@ -658,10 +658,7 @@ private def emitU8RangeCheck (i j : ValIdx) : Array RustStmt := let stmt : String := s!"if !unconstrained \{" ++ s!" let __vi = __v_{i}; let __vj = __v_{j};" ++ - s!" let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64();" ++ - s!" if __bi >= 256 \{ return Err(ExecError::U8RangeCheckFailed(__bi)); }" ++ - s!" if __bj >= 256 \{ return Err(ExecError::U8RangeCheckFailed(__bj)); }" ++ - s!" record.bytes2_queries.bump_range_check(&__vi, &__vj);" ++ + s!" record.bytes2_queries.bump_range_check(&__vi, &__vj)?;" ++ s!" }" #[.exprStmt (.lit stmt)] @@ -828,7 +825,7 @@ partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) .letStmt false "__ret" (some s!"[G; OUT_{funIdx}]") (.arrayLit (outs.map valVar)) let insertCall : RustStmt := .exprStmt (.lit <| - s!"record.function_queries[{funIdx}].finish(&inp[..], &__ret[..], !unconstrained)") + s!"record.function_queries[{funIdx}].finish_prehashed(&inp, &__ret[..], !unconstrained)?") -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. return #[outArr, insertCall, .returnStmt (.call (.var "Ok") #[.var "__ret"])] @@ -921,7 +918,8 @@ def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do let mut bindInputs : Array RustStmt := #[] for i in [0 : inSize] do bindInputs := bindInputs.push - (.letStmt false s!"__v_{i}" (some "G") (.index (.var "inp") (.lit (toString i)))) + (.letStmt false s!"__v_{i}" (some "G") + (.index (.call (.field (.var "inp") "values") #[]) (.lit (toString i)))) -- nextVal starts at inSize (the next free ValIdx after the inputs). let initState : EmitState := { nextVal := inSize, nextLabel := 0 } let (bodyStmts, _) := (emitBlock funIdx none f.body).run initState @@ -937,12 +935,13 @@ def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do let bodyText : String := stmtsToStr 2 body let fnText : String := s!"fn aiur_fn_{funIdx}(\n" ++ - s!" inp: [G; IN_{funIdx}],\n" ++ + s!" inp: QueryKey,\n" ++ s!" record: &mut QueryRecord,\n" ++ s!" io_buffer: &mut IOBuffer,\n" ++ s!" unconstrained: bool,\n" ++ s!") -> Result<[G; OUT_{funIdx}], ExecError> {lbrace}\n" ++ s!" stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {lbrace}\n" ++ + s!" record.checkpoint({funIdx});\n" ++ bodyText ++ s!" {rbrace})\n" ++ s!"{rbrace}\n\n" @@ -968,7 +967,8 @@ def emitPreludeHeader : String := )]\n\ \n\ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};\n\ - use aiur::G;\n" + use aiur::G;\n\ + use aiur::querymap::QueryKey;\n" /-- The set of optional `aiur::execute` items the codegen might emit references to. Each pair is `(rust_path, search_token)` @@ -1019,7 +1019,7 @@ def emitDispatch (tl : Toplevel) : RustItem := Id.run do .letStmt false "__inp" (some s!"[G; IN_{funIdx}]") (.lit "args.try_into().expect(\"input size mismatch\")"), .letStmt false "__out" none - (.lit s!"aiur_fn_{funIdx}(__inp, record, io_buffer, false)?"), + (.lit s!"aiur_fn_{funIdx}(QueryKey::new(__inp), record, io_buffer, false)?"), .returnStmt (.call (.var "Ok") #[.call (.field (.var "__out") "to_vec") #[]]) ] diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 691aa4d2f..aef8a1dc8 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -1023,9 +1023,9 @@ private def fileJson (path : String) (digest : Option (String × Nat)) shard the analytic prover RAM peak of the executed record is reported — the input to split (over a prover budget) / merge (far under it) decisions. Builds the `EnvHandle` ONCE, shared by every - shard. Coverage-gates the manifest before running any shard — exit - 0 has to mean "every env const was checked by some shard", same - soundness contract as `runShardCheckAll`. + shard. Coverage-gates the entire manifest before running any shard — exit + 0 means every selected shard's owned constants passed (every env constant + when no selection is given), never that skipped shards were checked. `opts` turns the batch into an audit: a selection of leaves, the proven-leaf guard, a JSON report, and `ix shard refine`'s failure @@ -1040,16 +1040,16 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- (`peakTreeRssBytes` reports 0 otherwise); started before the env -- load so the peak covers the whole run, like `check-rs`. if json?.isSome then TracingTexray.startSampler - -- The common whole-partition execution path keeps all environment-sized - -- work in Rust. Advanced refinement/selection/cache guards below retain - -- their existing driver; none may silently fall through to an all-shard run. - if maxRamBytes == 0 && outIxes.isNone && opts.selection.isNone && + -- Whole-partition and selected-shard execution keep all environment-sized + -- work in Rust. Destination prover budgets and proof-cache/refinement + -- output options below retain their existing driver; none may be ignored. + if maxRamBytes == 0 && outIxes.isNone && opts.provenGuard.isNone && !opts.emitOnFailure then let funIdx := compiled.getFuncIdx `verify_claim |>.get! let result ← compiled.bytecode.checkPartition funIdx ixePath manifestPath (jobs?.getD 0) useBytecode Aiur.defaultCommitmentParameters Aiur.defaultFriParameters (opts.report.getD "") (← gitRevision) - opts.command opts.budgetSource + opts.command opts.budgetSource opts.selection match result with | .error e => IO.eprintln s!"native partition check: {e}"; return 1 | .ok r => @@ -1103,9 +1103,8 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) -- One loop over execution waves. Wave 0 is the selected part of the -- planned partition; with a budget every over-budget leaf is cut into -- the peak model's suggested part count and the parts re-batched as - -- the next wave, until everything fits or is a single block. Without - -- a budget the FFI answers 1 part everywhere and the loop is a single - -- wave — the plain batch check. + -- the next wave, until everything fits or is a single block. Early + -- execution limits also split/retry, even without a prover budget. let mut wave : Array (Nat × String × Array Address × Array Address) := selected.filterMap fun k => if proven.contains k then none @@ -1120,6 +1119,7 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) let mut leafParts : Std.HashMap Nat (Array PartReport) := {} let mut totalConsts := 0 let mut elapsedMs := 0 + let mut pressureRetries : Std.HashMap String Nat := {} while wave.size > 0 do if waveNum == 0 then IO.println s!"Typechecking {wave.size} shard(s) in one rayon \ @@ -1129,24 +1129,30 @@ def runShardBatchNative (manifestPath ixePath : String) (jobs? : Option Nat) (← IO.getStdout).flush let ownedPer := wave.map (·.2.2.2) let start ← IO.monoMsNow - match compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle + match ← compiled.bytecode.shardCheckBatchWithEnv funIdx envHandle (addrListsBlob ownedPer) useBytecode jobs Aiur.defaultCommitmentParameters Aiur.defaultFriParameters maxRamBytes with | .error e => IO.eprintln s!"shard batch (wave {waveNum}): {e}"; return 1 | .ok rs => + -- Include every required retry in the measured execution window; + -- an interrupted wave-0 parent did not complete the requested check. + elapsedMs := elapsedMs + (← IO.monoMsNow) - start if waveNum == 0 then - -- The bench row's measured window: the planned partition's - -- batch call, matching `check-rs`. Split waves are audit - -- extras outside the benchmarked engine window. - elapsedMs := (← IO.monoMsNow) - start totalConsts := ownedPer.foldl (· + ·.size) 0 let mut next : Array (Nat × String × Array Address × Array Address) := #[] for (r, origin, label, blocks, owned) in rs.zip wave do let gib := toGib r.peakBytes if waveNum == 0 then leafPeak := leafPeak.insert origin r.peakBytes let mut settled : Option String := none - if !r.error.isEmpty then + if r.resourceStatus == 2 && pressureRetries.getD label 0 < 2 then + IO.eprintln s!"[shard {label}] batch execution memory limit — retry after wave drains" + pressureRetries := pressureRetries.insert label (pressureRetries.getD label 0 + 1) + next := next.push (origin, label, blocks, owned) + else if r.resourceStatus == 1 && blocks.size > 1 then + IO.eprintln s!"[shard {label}] execution memory limit — cut into 2 and retry" + next := next ++ cutLabeled origin label blocks owned 2 + else if !r.error.isEmpty then IO.eprintln s!"[shard {label}] FAILED: {r.error}" failed := failed.push s!"shard {label}: {r.error}" settled := some r.error @@ -1494,7 +1500,7 @@ def checkCmd : Cli.Cmd := `[Cli| "stats-out" : String; "Redirect the per-circuit statistics dump to this file (only used when exactly one constant is targeted)." "ixes" : String; "Path to a `.ixes` shard manifest (with --ixe). With --shard K: check the constants owned by shard K (ingress their closure, skip the frontier). Without --shard: check every shard of the partition concurrently, after a coverage check." "shard" : Nat; "0-based shard index K (with --ixe + --ixes): check the constants owned by shard K of the manifest's partition." - "jobs" : Nat; "Parallelism. With --ixes (no --shard): max shards checked concurrently (default: all at once). With --ixe alone and N ≠ 1: check the targeted constants on N Rust threads (0 = all cores), each claim over its own private record — peak RAM is bounded by N in-flight claim closures." + "jobs" : Nat; "Parallelism. With --ixes (no --shard): max shards checked concurrently (default: all at once); native coverage setup uses a separate pool (up to 8 CPUs, overridden by IX_AIUR_SETUP_THREADS). With --ixe alone and N ≠ 1: check the targeted constants on N Rust threads (0 = all cores), each claim over its own private record — peak RAM is bounded by N in-flight claim closures." "json" : String; "With --ixes (no --shard): append one env-keyed results row (see Ix.Benchmark.Results) for the batch to this file — check-time, throughput, peak-rss, constants, shards. Used by `ix bench run --backend aiur-sharded-env`." "json-name" : String; "Row key for the --json row (default: `env`)." "ram-budget" : Nat; "The destination prove box's per-shard RAM budget, GiB (with --ixes, no --shard): after the batch, cut every shard whose projected prover peak exceeds the budget into the peak model's suggested part count and re-batch the parts, wave by wave, until everything fits — the exec-only split audit. Under-filled partitions get a printed suggestion (the shard count the measured total says would fit), never an extra execution: re-shard with --shards N and let the next run's mandatory executions verify it inline. Same unit and model as `ix prove --max-ram`, but no auto-detection: the budget describes the prove box the partition is destined for, not the machine running the check. Omit for a plain check." diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 6e5e52b9b..37eab084f 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -83,7 +83,7 @@ def proveOne (aiurSystem : Aiur.AiurSystem) | .shard owned, some envHandle => let mut blob := ByteArray.empty for x in owned do blob := blob ++ x.hash - match aiurSystem.shardProveWithEnv funIdx envHandle blob with + match ← aiurSystem.shardProveWithEnv funIdx envHandle blob with | .error e => IO.eprintln s!"{label}: shardProveWithEnv error: {e}" return 1 @@ -161,7 +161,7 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) blob := blob ++ a.hash IO.println s!"Proving {label} ({blocks.size} blocks, {owned.size} consts)" (← IO.getStdout).flush - match aiurSystem.shardProveWithEnv funIdx envHandle blob maxRamBytes + match ← aiurSystem.shardProveWithEnv funIdx envHandle blob maxRamBytes execOnly with | .error e => return .error s!"{label}: shardProveWithEnv error: {e}" | .ok { claimBytes, proof, peakBytes, suggestedParts } => @@ -176,11 +176,16 @@ partial def proveBlocksWithinBudget (envHandle : Aiur.EnvHandle) -- A single block is the atom the kernel checks together; there is -- no smaller shard to fall back to. if blocks.size <= 1 then + if peakBytes == 0 then + return .error s!"{label}: execution memory limit reached and the shard is a single block — cannot split" return .error s!"{label}: projected prover peak {gib} GiB exceeds \ the budget and the shard is a single block — raise --max-ram" let cut := Ix.Cli.CheckCmd.cutBlocks blocks suggestedParts - IO.println s!"[{label}] peak {gib} GiB over budget — cutting \ - {blocks.size} blocks into {cut.size} parts" + if peakBytes == 0 then + IO.println s!"[{label}] execution memory limit — cutting {blocks.size} blocks into {cut.size} parts" + else + IO.println s!"[{label}] peak {gib} GiB over budget — cutting \ + {blocks.size} blocks into {cut.size} parts" let cutOwned := Ix.Cli.CheckCmd.partitionOwned ixonEnv owned cut let mut proven : Array (Array Address × Nat) := #[] for (i, part, po) in (cut.zip cutOwned).mapIdx diff --git a/Ix/IxVM/FunctionGroups.lean b/Ix/IxVM/FunctionGroups.lean index 27820e1fb..be10c0068 100644 --- a/Ix/IxVM/FunctionGroups.lean +++ b/Ix/IxVM/FunctionGroups.lean @@ -20,6 +20,9 @@ namespace IxVM -- workload), capped at 16 members and 40 selectors per group, within an -- average 2% (max 4%) cost increase per workload. 83 groups over 656 of -- 743 groupable circuits: 744 -> 171 circuits. +-- These measurements describe the original grouping. The FLT arithmetic +-- changes remove list_snoc.U8_8 and add helpers that retain singleton circuits; +-- preserve surviving groups, but remeasure costs for the combined kernel. def functionGroups : Array (String × Array String) := #[ ("ixvm_group_00", #[ "memo_u32_less_than", @@ -364,8 +367,7 @@ def functionGroups : Array (String × Array String) := #[ "lazy_delta_b_const_a_proj" ]), ("ixvm_group_29", #[ - "get_address_list", - "list_snoc.U8_8" + "get_address_list" ]), ("ixvm_group_30", #[ "unpack_def_kind_safety", diff --git a/Ix/IxVM/Kernel/Klimbs.lean b/Ix/IxVM/Kernel/Klimbs.lean index 89dd9b890..147f40493 100644 --- a/Ix/IxVM/Kernel/Klimbs.lean +++ b/Ix/IxVM/Kernel/Klimbs.lean @@ -25,25 +25,76 @@ Ops covered: - klimbs_shl / klimbs_shr (via mul/div by 2^n) - u64_add / u64_mul (byte schoolbook) / u64_sub_with_borrow / u64_and / u64_or / u64_xor_kbits (element-wise byte ops) -- divmod_256 / split_carry (unconstrained witness generators for - u64_mul column decomposition) +- split_carry (constant-time unconstrained byte hint for u64_mul columns) Aiur builtin gadgets used (compiler-provided): u8_add, u8_sub, u8_xor, u8_and, u8_or, u8_from_field_unsafe, u32_less_than, -u64_add, u64_is_zero, list_snoc, unconstrained_big_uint_div_mod, -#split_carry. +u64_add, u64_is_zero, unconstrained_big_uint_div_mod, +#split_carry, unconstrained_g_to_bytes. -/ set_option maxRecDepth 16384 in def klimbs := ⟦ + -- Checked successor with carry-out. Unlike adding a whole zero-padded + -- U64 one, this needs eight byte-add lookups instead of fifteen and its + -- memo key holds just one limb. Every input/output byte is still checked + -- by u8_add, including bytes above the point where carry stops. + fn u64_succ_carry(a: U64) -> (U64, U8) { + let [a0, a1, a2, a3, a4, a5, a6, a7] = a; + let (s0, c1) = u8_add(a0, 1u8); + let (s1, c2) = u8_add(a1, c1); + let (s2, c3) = u8_add(a2, c2); + let (s3, c4) = u8_add(a3, c3); + let (s4, c5) = u8_add(a4, c4); + let (s5, c6) = u8_add(a5, c5); + let (s6, c7) = u8_add(a6, c6); + let (s7, c8) = u8_add(a7, c7); + ([s0, s1, s2, s3, s4, s5, s6, s7], c8) + } + + -- Fused a + b + 1. Keep the carry-zero case on u64_add; specializing the + -- carry-one case avoids a second full-width memo row and a second ripple + -- over the limb. Sixteen checked byte adds versus thirty for two u64_adds. + -- At each column the two overflow bits are mutually exclusive: if a+b + -- overflowed, its low byte is <= 254, so adding a carry bit cannot overflow. + fn u64_add_carry_one(a: U64, b: U64) -> (U64, U8) { + let [a0, a1, a2, a3, a4, a5, a6, a7] = a; + let [b0, b1, b2, b3, b4, b5, b6, b7] = b; + let (t0, o0) = u8_add(a0, b0); + let (s0, c0a) = u8_add(t0, 1u8); + let c1 = u8_from_field_unsafe(to_field(o0) + to_field(c0a)); + let (t1, o1) = u8_add(a1, b1); + let (s1, c1a) = u8_add(t1, c1); + let c2 = u8_from_field_unsafe(to_field(o1) + to_field(c1a)); + let (t2, o2) = u8_add(a2, b2); + let (s2, c2a) = u8_add(t2, c2); + let c3 = u8_from_field_unsafe(to_field(o2) + to_field(c2a)); + let (t3, o3) = u8_add(a3, b3); + let (s3, c3a) = u8_add(t3, c3); + let c4 = u8_from_field_unsafe(to_field(o3) + to_field(c3a)); + let (t4, o4) = u8_add(a4, b4); + let (s4, c4a) = u8_add(t4, c4); + let c5 = u8_from_field_unsafe(to_field(o4) + to_field(c4a)); + let (t5, o5) = u8_add(a5, b5); + let (s5, c5a) = u8_add(t5, c5); + let c6 = u8_from_field_unsafe(to_field(o5) + to_field(c5a)); + let (t6, o6) = u8_add(a6, b6); + let (s6, c6a) = u8_add(t6, c6); + let c7 = u8_from_field_unsafe(to_field(o6) + to_field(c6a)); + let (t7, o7) = u8_add(a7, b7); + let (s7, c7a) = u8_add(t7, c7); + let c8 = u8_from_field_unsafe(to_field(o7) + to_field(c7a)); + ([s0, s1, s2, s3, s4, s5, s6, s7], c8) + } + -- Mirror: BigUint::succ. Increment a KLimbs by 1; ripple carry. fn klimbs_succ(n: KLimbs) -> KLimbs { match load(n) { ListNode.Nil => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))), ListNode.Cons(limb, rest) => - let pair = u64_add(limb, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + let pair = u64_succ_carry(limb); match pair { (sum, carry) => match carry { @@ -63,28 +114,23 @@ def klimbs := ⟦ ListNode.Nil => match carry { 0 => b, - _ => klimbs_succ(b), + 1 => klimbs_succ(b), }, ListNode.Cons(la, ra) => match load(b) { ListNode.Nil => match carry { 0 => a, - _ => klimbs_succ(a), + 1 => klimbs_succ(a), }, ListNode.Cons(lb, rb) => - let pair1 = u64_add(la, lb); - match pair1 { - (sum1, carry1) => - let pair2 = u64_add(sum1, [u8_from_field_unsafe(carry), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); - match pair2 { - (sum2, carry2) => - -- carry1, carry2 mutually exclusive: carry1=1 ⇒ sum1 ≤ - -- 2^64-2 ⇒ sum1 + carry_in ≤ 2^64-1 ⇒ carry2=0. - let total_carry = to_field(carry1) + to_field(carry2); - store(ListNode.Cons(sum2, klimbs_add_carry(ra, rb, total_carry))), - }, - }, + -- Dispatch before the helper call so zero carry leaves no + -- add-zero row. The carry is a BIT, not an arbitrary byte. + let (sum, next) = match carry { + 0 => u64_add(la, lb), + 1 => u64_add_carry_one(la, lb), + }; + store(ListNode.Cons(sum, klimbs_add_carry(ra, rb, to_field(next)))), }, } } @@ -260,29 +306,19 @@ def klimbs := ⟦ klimbs_sub(a, one) } - -- Returns (remainder, quotient): remainder = x mod 256, quotient = x / 256. - -- Repeated subtraction. Only ever invoked from the `#split_carry` / - -- `#split_u32` unconstrained witness generators, so the O(x/256) - -- iteration cost is off-circuit (untraced). - fn divmod_256(x: G, q: G) -> (G, G) { - match u32_less_than(x, 256) { - 1 => (x, q), - 0 => divmod_256(x - 256, q + 1), - } - } - -- Unconstrained witness generator: split `x` into its low byte `limb` -- and the two bytes (clo, chi) of `x div 256`. Always invoked as -- `#split_carry(...)`; the result is prover-provided and MUST be pinned - -- by the caller with u8 range checks + a reconstruction assert. The - -- division here is off-circuit (untraced), so its cost is irrelevant. + -- by the caller with u8 range checks + a reconstruction assert. + -- + -- The native byte hint avoids repeated-subtraction division: even an + -- unconstrained Aiur call retains memo rows, so the old O(x/256) loop + -- consumed substantial execution time and RAM despite having no circuit. + -- Valid u64_mul columns are < 2^19, hence the low three bytes suffice. + -- The hint itself is NOT trusted; all existing caller checks remain. fn split_carry(x: G) -> (G, G, G) { - match divmod_256(x, 0) { - (limb, quot) => - match divmod_256(quot, 0) { - (clo, chi) => (limb, clo, chi), - }, - } + let [limb, clo, chi, _, _, _, _, _] = unconstrained_g_to_bytes(x); + (limb, clo, chi) } -- u64×u64 → (lo: U64, hi: U64) via byte schoolbook. Faithful port of the @@ -450,38 +486,122 @@ def klimbs := ⟦ } } - -- Mirror: BigUint::mul. Limb-wise schoolbook multiply. + -- Mirror: BigUint::mul. Schoolbook multiplication, streaming later product + -- rows into the accumulator instead of retaining separate product/shifted + -- lists. Tests/Ix/IxVM/FusedMul.lean retains the old composition and a + -- producer/consumer fusion proof parameterized by the arithmetic steps. fn klimbs_mul(a: KLimbs, b: KLimbs) -> KLimbs { - klimbs_mul_outer(a, b, store(ListNode.Nil), 0) + -- The first row has no accumulator and no shift. Use its already-linear + -- builder directly: avoid recording fused-row, shift-zero and add-empty + -- wrappers when there is no producer/consumer pair to fuse. + match load(a) { + ListNode.Nil => store(ListNode.Nil), + ListNode.Cons(limb, rest) => + let first = klimbs_mul_single(limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + klimbs_mul_acc_outer(rest, b, first, 1), + } } - fn klimbs_mul_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs { + fn klimbs_mul_acc_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs { match load(a) { ListNode.Nil => acc, ListNode.Cons(a_limb, rest) => - let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)); - let shifted = klimbs_shl_limbs(prod, shift); - let new_acc = klimbs_add(acc, shifted); - klimbs_mul_outer(rest, b, new_acc, shift + 1), + let next = klimbs_mul_acc_shift(a_limb, b, acc, shift); + klimbs_mul_acc_outer(rest, b, next, shift + 1), } } - fn klimbs_mul_single(a_limb: U64, b: KLimbs, carry: U64, acc: KLimbs) -> KLimbs { + -- acc + (row << shift). Copy the unchanged low accumulator prefix but + -- retain the old checked add-zero operation, not an assumption that loaded + -- U64-typed fields have already been byte-range-checked. An empty product + -- still contributes shift zero limbs, exactly like klimbs_shl_limbs. + fn klimbs_mul_acc_shift(a: U64, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs { + match shift { + 0 => klimbs_mul_acc_row(a, b, acc, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], 0), + _ => match load(acc) { + ListNode.Nil => store(ListNode.Cons([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], + klimbs_mul_acc_shift(a, b, acc, shift - 1))), + ListNode.Cons(limb, rest) => + let (sum, carry) = u64_add(limb, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + assert_eq!(carry, 0u8, "multiply-accumulate prefix overflow"); + store(ListNode.Cons(sum, klimbs_mul_acc_shift(a, b, rest, shift - 1))), + }, + } + } + + -- EXACTLY add_carry(acc, mul_single(a, b, mul_carry), add_carry). + -- Keep the two original carries separate: no new arithmetic identity is + -- trusted and a carry from adding the accumulator never changes the product + -- recurrence. Only the intermediate product-list nodes disappear. Empty + -- tails retain the existing helpers' zero/trailing-limb behavior. + fn klimbs_mul_acc_row(a: U64, b: KLimbs, acc: KLimbs, + mul_carry: U64, add_carry: G) -> KLimbs { + match load(b) { + ListNode.Nil => klimbs_add_carry(acc, klimbs_mul_single(a, b, mul_carry), add_carry), + ListNode.Cons(b_limb, b_rest) => match load(acc) { + ListNode.Nil => klimbs_add_carry(acc, klimbs_mul_single(a, b, mul_carry), add_carry), + ListNode.Cons(acc_limb, acc_rest) => + let (lo, hi) = u64_mul(a, b_limb); + let (digit, carry_out) = u64_add(lo, mul_carry); + -- Branch-local continuation avoids joining a full eight-byte carry + -- into the hot circuit. Match the already-validated row builder. + match to_field(carry_out) { + 0 => + let (sum, next) = match add_carry { + 0 => u64_add(acc_limb, digit), + 1 => u64_add_carry_one(acc_limb, digit), + }; + store(ListNode.Cons(sum, + klimbs_mul_acc_row(a, b_rest, acc_rest, hi, to_field(next)))), + 1 => + let (high, overflow) = u64_succ_carry(hi); + assert_eq!(overflow, 0u8, "multiplication row carry overflow"); + let (sum, next) = match add_carry { + 0 => u64_add(acc_limb, digit), + 1 => u64_add_carry_one(acc_limb, digit), + }; + store(ListNode.Cons(sum, + klimbs_mul_acc_row(a, b_rest, acc_rest, high, to_field(next)))), + }, + }, + } + } + + -- Build the little-endian result by consing each low limb onto the + -- recursively computed higher limbs. The previous accumulator used + -- list_snoc for every limb, copying prefixes quadratically and retaining + -- their memo/memory rows. This visits each input limb once and also drops + -- the irrelevant output prefix from the memo key. + -- + -- For any old prefix acc: old_row(a, b, carry, acc) = acc ++ row(a, b, carry). + -- The arithmetic relation is preserved. Keep zero limbs in the body and + -- omit only a zero FINAL carry, exactly as before; normalization belongs + -- to the existing callers, not this list-construction optimization. + fn klimbs_mul_single(a_limb: U64, b: KLimbs, carry: U64) -> KLimbs { match load(b) { ListNode.Nil => match u64_is_zero(carry) { - 1 => acc, - 0 => list_snoc(acc, carry), + 1 => store(ListNode.Nil), + 0 => store(ListNode.Cons(carry, store(ListNode.Nil))), }, ListNode.Cons(b_limb, rest) => match u64_mul(a_limb, b_limb) { (lo, hi) => match u64_add(lo, carry) { (sum, carry_out) => - match u64_add(hi, [carry_out, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]) { - (new_carry, _) => - let new_acc = list_snoc(acc, sum); - klimbs_mul_single(a_limb, rest, new_carry, new_acc), + -- Keep the recursive call in each branch: joining an + -- eight-byte carry first adds nine avoidable circuit + -- columns. The branch-local form has the same memo rows. + match to_field(carry_out) { + 0 => store(ListNode.Cons(sum, + klimbs_mul_single(a_limb, rest, hi))), + 1 => + let (next, overflow) = u64_succ_carry(hi); + -- For byte-canonical operands, hi <= 2^64 - 2. + -- Keep that no-overflow obligation explicit. + assert_eq!(overflow, 0u8, "multiplication row carry overflow"); + store(ListNode.Cons(sum, + klimbs_mul_single(a_limb, rest, next))), }, }, }, diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean index b8416b197..969e66f18 100644 --- a/Ix/IxVM/Kernel/NatPrim.lean +++ b/Ix/IxVM/Kernel/NatPrim.lean @@ -1062,22 +1062,14 @@ def natPrim := ⟦ } } - -- G (< 2^32) → single-limb KLimbs via prover-provided 4-byte split. - -- Pinned by u8 range checks + reconstruction assert. `x >= 2^32` - -- rejected (assert fails), not silently truncated. + -- Constant-time 4-byte hint, called only as `#split_u32`. The low bytes + -- alone are not a checked conversion: `klimbs_from_g` below range-checks + -- them and reconstructs x, rejecting x >= 2^32 rather than truncating it. + -- Avoid recursive subtraction here: unconstrained calls still retain + -- execution memo rows, although they do not contribute circuit rows. fn split_u32(x: G) -> (G, G, G, G) { - match divmod_256(x, 0) { - (b0, q1) => - match divmod_256(q1, 0) { - (b1, q2) => - match divmod_256(q2, 0) { - (b2, q3) => - match divmod_256(q3, 0) { - (b3, _) => (b0, b1, b2, b3), - }, - }, - }, - } + let [b0, b1, b2, b3, _, _, _, _] = unconstrained_g_to_bytes(x); + (b0, b1, b2, b3) } -- Convert G value (< 2^32) into single-limb KLimbs. The 4-byte diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean index 1a1b8bef9..4755682eb 100644 --- a/Ix/IxVM/Kernel/Subst.lean +++ b/Ix/IxVM/Kernel/Subst.lean @@ -527,15 +527,68 @@ def subst := ⟦ let n = list_length(substs); match n { 0 => e, - _ => - let l = expr_lbr(e); - match memo_u32_less_than(depth, l) { - 0 => e, - 1 => - match has_bvar_in_range(e, depth, depth + n) { - 1 => expr_inst_many_walk(e, substs, depth), - _ => expr_lower(e, n, depth + n), - }, + _ => expr_inst_many_projected(e, substs, n, depth), + } + } + + -- One plus the highest REFERENCED offset in [lo, hi), or zero. The + -- summary depends on the expression/window, never substitution values. + -- If all loose variables lie below hi, expr_lbr gives the exact answer + -- without another expression walk. A high variable outside the window + -- must not prevent dropping an irrelevant substitution tail. + fn expr_inst_prefix_len(e: KExpr, lo: G, hi: G) -> G { + let l = expr_lbr(e); + match memo_u32_less_than(lo, l) { + 0 => 0, + 1 => match memo_u32_less_than(hi, l) { + 0 => l - lo, + 1 => expr_inst_prefix_walk(e, lo, hi), + }, + } + } + + fn expr_inst_prefix_walk(e: KExpr, lo: G, hi: G) -> G { + match load(e) { + KExprNode.BVar(i) => match memo_u32_less_than(i, lo) { + 1 => 0, + 0 => match memo_u32_less_than(i, hi) { + 1 => i - lo + 1, + 0 => 0, + }, + }, + KExprNode.App(f, a) => + lbr_max(expr_inst_prefix_len(f, lo, hi), expr_inst_prefix_len(a, lo, hi)), + KExprNode.Lam(ty, body) => + lbr_max(expr_inst_prefix_len(ty, lo, hi), expr_inst_prefix_len(body, lo + 1, hi + 1)), + KExprNode.Forall(ty, body) => + lbr_max(expr_inst_prefix_len(ty, lo, hi), expr_inst_prefix_len(body, lo + 1, hi + 1)), + KExprNode.Let(ty, val, body) => expr_inst_prefix_let(ty, val, body, lo, hi), + KExprNode.Proj(_, _, inner) => expr_inst_prefix_len(inner, lo, hi), + _ => 0, + } + } + + fn expr_inst_prefix_let(ty: KExpr, val: KExpr, body: KExpr, lo: G, hi: G) -> G { + lbr_max(lbr_max(expr_inst_prefix_len(ty, lo, hi), expr_inst_prefix_len(val, lo, hi)), + expr_inst_prefix_len(body, lo + 1, hi + 1)) + } + + -- substs can be an already projected prefix. n is ALWAYS the original + -- number of binders removed, not list_length(substs). This is essential: + -- higher variables still lower by n, and depth still prevents capture. + -- Every recursive child uses only offsets present in its parent's prefix. + fn expr_inst_many_projected(e: KExpr, substs: List‹KExpr›, n: G, depth: G) -> KExpr { + let l = expr_lbr(e); + match memo_u32_less_than(depth, l) { + 0 => e, + 1 => + let needed = expr_inst_prefix_len(e, depth, depth + n); + match needed { + 0 => expr_lower(e, n, depth + n), + _ => match n - needed { + 0 => expr_inst_many_walk(e, substs, n, depth), + _ => expr_inst_many_walk(e, list_take(substs, needed), n, depth), + }, }, } } @@ -549,8 +602,7 @@ def subst := ⟦ -- `i ≥ depth`, so the window test reduces to one comparison on the -- offset. A sub-`depth` index (invariant violation) wraps in the field -- and fails the u32 range decomposition — no silent path. - fn expr_inst_many_bvar(i: G, substs: List‹KExpr›, depth: G) -> KExpr { - let n = list_length(substs); + fn expr_inst_many_bvar(i: G, substs: List‹KExpr›, n: G, depth: G) -> KExpr { let ofs = i - depth; match memo_u32_less_than(ofs, n) { 1 => expr_lift(list_lookup(substs, ofs), depth, 0), @@ -558,38 +610,38 @@ def subst := ⟦ } } - fn expr_inst_many_walk(e: KExpr, substs: List‹KExpr›, depth: G) -> KExpr { + fn expr_inst_many_walk(e: KExpr, substs: List‹KExpr›, n: G, depth: G) -> KExpr { match load(e) { - KExprNode.BVar(i) => expr_inst_many_bvar(i, substs, depth), + KExprNode.BVar(i) => expr_inst_many_bvar(i, substs, n, depth), KExprNode.Srt(l) => store(KExprNode.Srt(l)), KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), KExprNode.App(f, a) => store(KExprNode.App( - expr_inst_many(f, substs, depth), - expr_inst_many(a, substs, depth))), + expr_inst_many_projected(f, substs, n, depth), + expr_inst_many_projected(a, substs, n, depth))), KExprNode.Lam(ty, body) => store(KExprNode.Lam( - expr_inst_many(ty, substs, depth), - expr_inst_many(body, substs, depth + 1))), + expr_inst_many_projected(ty, substs, n, depth), + expr_inst_many_projected(body, substs, n, depth + 1))), KExprNode.Forall(ty, body) => store(KExprNode.Forall( - expr_inst_many(ty, substs, depth), - expr_inst_many(body, substs, depth + 1))), + expr_inst_many_projected(ty, substs, n, depth), + expr_inst_many_projected(body, substs, n, depth + 1))), KExprNode.Let(ty, val, body) => - expr_inst_many_let(ty, val, body, substs, depth), + expr_inst_many_let(ty, val, body, substs, n, depth), KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), KExprNode.Proj(tidx, fidx, e1) => - store(KExprNode.Proj(tidx, fidx, expr_inst_many(e1, substs, depth))), + store(KExprNode.Proj(tidx, fidx, expr_inst_many_projected(e1, substs, n, depth))), } } -- Cold-extracted Let arm (same pattern as `expr_lbr_let`). fn expr_inst_many_let(ty: KExpr, val: KExpr, body: KExpr, - substs: List‹KExpr›, depth: G) -> KExpr { + substs: List‹KExpr›, n: G, depth: G) -> KExpr { store(KExprNode.Let( - expr_inst_many(ty, substs, depth), - expr_inst_many(val, substs, depth), - expr_inst_many(body, substs, depth + 1))) + expr_inst_many_projected(ty, substs, n, depth), + expr_inst_many_projected(val, substs, n, depth), + expr_inst_many_projected(body, substs, n, depth + 1))) } ⟧ diff --git a/Tests/Cli/NativePartition.lean b/Tests/Cli/NativePartition.lean index 381b208c6..664876d62 100644 --- a/Tests/Cli/NativePartition.lean +++ b/Tests/Cli/NativePartition.lean @@ -39,9 +39,11 @@ public def run : IO Unit := do let toplevel ← IO.ofExcept IxVM.ixVM let compiled ← IO.ofExcept toplevel.compile let funIdx := compiled.getFuncIdx `verify_claim |>.get! - let check := fun bytecode jobs => compiled.bytecode.checkPartition funIdx + let checkSelected := fun (selection : Option (Array Nat)) bytecode jobs => + compiled.bytecode.checkPartition funIdx ixe.toString ixes.toString jobs bytecode Aiur.defaultCommitmentParameters - Aiur.defaultFriParameters report.toString "test" "ix check" "none" + Aiur.defaultFriParameters report.toString "test" "ix check" "none" selection + let check := checkSelected none let legacyHandle ← IO.ofExcept (Aiur.EnvHandle.fromBytes bytes) let owned := Ix.Cli.CheckCmd.ownedConstsPer env shards expect (← Ix.Cli.CheckCmd.shardsCover env shards) "reference coverage failed" @@ -49,11 +51,15 @@ public def run : IO Unit := do let native ← IO.ofExcept (← check bytecode 2) expect (native.constants == 2 && native.shards == 2 && native.failures == 0) "native full-partition execution/counts failed" - let legacy ← IO.ofExcept (compiled.bytecode.shardCheckBatchWithEnv funIdx + let legacy ← IO.ofExcept (← compiled.bytecode.shardCheckBatchWithEnv funIdx legacyHandle (Ix.Cli.CheckCmd.addrListsBlob owned) bytecode 2) expect (legacy.size == 2 && legacy.all (·.error.isEmpty)) "legacy shard execution disagrees with native setup" let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) + expect ((← IO.ofExcept (audit.getObjValAs? String "scheduler")) == "completion-driven" && + (← IO.ofExcept (audit.getObjVal? "waves")) == .null && + (← IO.ofExcept (audit.getObjValAs? Nat "executed")) == 2) + "native scheduler audit still reports batch-wave semantics" let leaves ← IO.ofExcept (audit.getObjValAs? (Array Lean.Json) "leaves") expect (leaves.size == 2) "native audit omitted leaves" for (addresses, id) in owned.mapIdx (fun id addresses => (addresses, id)) do @@ -63,34 +69,194 @@ public def run : IO Unit := do expect (actual == expected) "native audit changed a shard claim digest" let peak ← IO.ofExcept (leaves[id]!.getObjValAs? Nat "predicted_peak_bytes") expect (peak == legacy[id]!.peakBytes) "native execution record/peak disagrees with legacy" + -- The dependent consumer needs the skipped shard's declaration as + -- frontier input, but must not claim that shard was checked. Selecting + -- only shard 1 also detects accidental compact-id remapping to shard 0. + for selection in [#[0], #[1], #[1, 0, 1]] do + let selected := selection.toList.eraseDups.toArray + let subset ← IO.ofExcept (← checkSelected (some selection) bytecode 2) + expect (subset.constants == selected.size && subset.shards == selected.size && + subset.failures == 0) "selected counts include skipped or duplicated shards" + let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) + let leaves ← IO.ofExcept (audit.getObjValAs? (Array Lean.Json) "leaves") + expect (leaves.size == shards.size) "selected audit dropped original manifest leaves" + for id in [:shards.size] do + expect ((← IO.ofExcept (leaves[id]!.getObjValAs? Nat "id")) == id) + "selected audit renumbered a manifest leaf" + let status ← IO.ofExcept (leaves[id]!.getObjValAs? String "status") + if selected.contains id then + expect (status == "measured") "selected shard was not executed" + let (claim, _) ← IO.ofExcept + (IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned[id]!) + expect ((← IO.ofExcept (leaves[id]!.getObjValAs? String "claim")) == + toString (Address.blake3 (Ix.Claim.ser claim))) + "selected claim differs from the legacy claim" + expect ((← IO.ofExcept (leaves[id]!.getObjValAs? Nat "predicted_peak_bytes")) == + legacy[id]!.peakBytes) "selected execution record differs from legacy" + else + expect (status == "unchanged") "skipped shard was reported checked" + expect ((← IO.ofExcept (leaves[id]!.getObjVal? "claim")) == .null && + (← IO.ofExcept (leaves[id]!.getObjVal? "predicted_peak_bytes")) == .null) + "skipped shard acquired a claim or measured peak" + for selection in [#[], #[2], #[2^128]] do + expect (!(← checkSelected (some selection) false 2).isOk) + "invalid/empty/oversized selection was accepted by the FFI" -- Exercise actual CLI dispatch and ensure options that still need the -- legacy wave driver are never silently ignored by the native fast path. let ix ← IO.FS.realPath ".lake/build/bin/ix" - for (extra, nativePath, selected, budget) in - [(#[], true, 2, 0), (#["--shards", "0"], false, 1, 0), - (#["--ram-budget", "1"], false, 2, 1024 * 1024 * 1024)] do - let out ← IO.Process.output { cmd := ix.toString, args := - #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, - "--jobs", "2", "--report", report.toString, - "--json", (dir / "results.json").toString] ++ extra } + for (extra, nativePath, selected, budget, jobs) in + [(#[], true, 2, 0, 1), (#[], true, 2, 0, 2), (#[], true, 2, 0, 64), + (#["--shards", "0"], true, 1, 0, 2), + (#["--shards", "1"], true, 1, 0, 2), + (#["--shards", "1,0-1,1"], true, 2, 0, 2), + (#["--shards", "1", "--interp", "bytecode"], true, 1, 0, 2), + (#["--shards", "1", "--ram-budget", "1"], false, 1, 1024 * 1024 * 1024, 2), + (#["--ram-budget", "1"], false, 2, 1024 * 1024 * 1024, 2)] do + -- Opt-in final scans must work for native/bytecode and legacy setup, + -- and remain silent when explicitly disabled, irrespective of the + -- environment of the surrounding test runner. + let profile := selected == 1 + let out ← IO.Process.output { + cmd := ix.toString + args := #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, + "--jobs", toString jobs, "--report", report.toString, + "--json", (dir / "results.json").toString] ++ extra + env := #[("IX_AIUR_SETUP_THREADS", some "2"), ("RAYON_NUM_THREADS", some "1"), + ("IX_AIUR_COMPACT_MULTIPLICITIES", some (if profile then "1" else "0")), + ("IX_AIUR_MULTIPLICITY_STATS", some (if profile then "1" else "0"))] + } expect (out.exitCode == 0) s!"partition CLI failed: {out.stdout}\n{out.stderr}" expect (out.stderr.contains "[ixvm_setup]" == nativePath) "partition CLI routed to the wrong setup path" + expect (out.stderr.contains "[ixvm_memory]") + "partition CLI omitted memory-admission diagnostics" + expect (out.stderr.contains "reason=" && out.stderr.contains "psi_avg10=") + "partition CLI omitted the admission backoff reason/pressure trend" + expect (out.stderr.contains "[aiur-multiplicity]" == profile) + "multiplicity diagnostics ignored the opt-in setting" + if profile then + expect (out.stderr.contains "status=returned" && + out.stderr.contains "map=functions" && out.stderr.contains "map=memory" && + out.stderr.contains "snapshot_only=true" && + out.stderr.contains "stored_payload_bytes=" && + out.stderr.contains "stored_segments_u32_field=" && + out.stderr.contains "reservation_peak_bytes=") + "successful execution omitted its bounded multiplicity snapshot" + if nativePath then + expect (out.stderr.contains "completion-driven queue" && + out.stderr.contains "attempt=" && out.stderr.contains "generation=") + "native partition CLI omitted completion-driven attempt reporting" + expect (out.stderr.contains s!"{selected}/{selected} shards") + "native partition CLI omitted shard completions" + expect (out.stderr.contains "(2 setup threads)") + "native setup ignored its independent thread count" + if jobs == 1 then + expect (out.stderr.contains "limit=1/1" && out.stderr.contains "1 thread(s)") + "parallel setup widened single-worker execution" let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) expect ((← IO.ofExcept (audit.getObjValAs? Nat "selected")) == selected) "partition CLI ignored a shard selection" expect ((← IO.ofExcept (audit.getObjValAs? Nat "budget_bytes")) == budget) "partition CLI ignored a refinement budget" + -- Compact counters must preserve the same claims as the full-width + -- reference setup, also on the bytecode and legacy CLI paths. + let leaves ← IO.ofExcept (audit.getObjValAs? (Array Lean.Json) "leaves") + for (leaf, id) in leaves.mapIdx (fun id leaf => (leaf, id)) do + if (← IO.ofExcept (leaf.getObjValAs? String "status")) == "measured" then + let (claim, _) ← IO.ofExcept + (IxVM.ClaimHarness.shardCheckEnvClaimTrees env owned[id]!) + expect ((← IO.ofExcept (leaf.getObjValAs? String "claim")) == + toString (Address.blake3 (Ix.Claim.ser claim))) + "compact-counter CLI changed a selected claim digest" + let rows ← Ix.Benchmark.Results.readRows (dir / "results.json").toString + let row ← IO.ofExcept (rows.getObjVal? "env") + expect ((← IO.ofExcept (row.getObjValAs? Nat "constants")) == selected) + "benchmark row counted unselected constants" + expect ((← IO.ofExcept (row.getObjValAs? Nat "shards")) == selected) + "benchmark row counted unselected shards" + for setting in ["0", "invalid", "184467440737095516160"] do + let out ← IO.Process.output { + cmd := ix.toString + args := #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, "--jobs", "1"] + env := #[("IX_AIUR_SETUP_THREADS", some setting)] + } + expect (out.exitCode != 0 && out.stderr.contains "IX_AIUR_SETUP_THREADS" && + !out.stderr.contains "[ixvm_check]") "bad setup thread count reached execution" + for selection in ["", "2", "340282366920938463463374607431768211456"] do + let out ← IO.Process.output { cmd := ix.toString, args := + #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, + "--shards", selection, "--jobs", "2"] } + expect (out.exitCode != 0 && !out.stderr.contains "[ixvm_check]") + "invalid CLI selection reached execution" + -- Force mid-execution record limits in both executors. A limited parent + -- must split; a still-limited singleton must fail, not report success or + -- loop forever. The legacy wave driver must consume the same typed result. + IO.FS.writeBinFile ixes (manifestBytes #[#[consumerAddr, dependencyAddr]]) + for extra in [#[], #["--interp", "bytecode"], #["--ram-budget", "1"]] do + let out ← IO.Process.output { + cmd := ix.toString + args := #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, + "--jobs", "2", "--report", report.toString] ++ extra + env := #[("IX_AIUR_EXEC_MAX_BYTES", some "67108864"), + ("IX_AIUR_COMPACT_MULTIPLICITIES", some "1"), + ("IX_AIUR_MULTIPLICITY_STATS", some "1")] } + expect (out.exitCode != 0) "resource-limited execution reported success" + expect (out.stderr.contains "[ixvm_record]") "missing execution-limit diagnostics" + expect (out.stderr.contains "status=resource-limit" && + out.stderr.contains "[aiur-multiplicity]") + "partial execution omitted its resource-limit multiplicity snapshot" + expect (out.stderr.contains "split" || out.stderr.contains "cut into 2") + s!"oversized parent was not refined: {out.stdout}\n{out.stderr}" + let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) + let failures ← IO.ofExcept (audit.getObjValAs? (Array Lean.Json) "failures") + expect (!failures.isEmpty) "resource-limited leaves disappeared from the report" + IO.FS.writeBinFile ixes (manifestBytes shards) + -- Select a nonzero original id and force its split. The unselected leaf + -- must remain untouched even when every selected child is resource-limited. + IO.FS.writeBinFile ixes (manifestBytes #[#[], #[consumerAddr, dependencyAddr]]) + for extra in [#[], #["--interp", "bytecode"]] do + let out ← IO.Process.output { + cmd := ix.toString + args := #["check", "--ixe", ixe.toString, "--ixes", ixes.toString, + "--shards", "1", "--jobs", "2", "--report", report.toString] ++ extra + env := #[("IX_AIUR_EXEC_MAX_BYTES", some "67108864")] } + expect (out.exitCode != 0 && out.stderr.contains "shard 1: execution memory limit") + s!"selected oversized parent was not refined natively: {out.stderr}" + let audit ← IO.ofExcept (Lean.Json.parse (← IO.FS.readFile report)) + let leaves ← IO.ofExcept (audit.getObjValAs? (Array Lean.Json) "leaves") + expect ((← IO.ofExcept (leaves[0]!.getObjValAs? String "status")) == "unchanged") + "resource refinement executed an unselected leaf" + let parts ← IO.ofExcept (leaves[1]!.getObjValAs? (Array Lean.Json) "parts") + expect (parts.size == 2) "selected resource refinement lost a child" + for part in parts do + expect ((← IO.ofExcept (part.getObjValAs? String "label")).startsWith "1.") + "selected refinement renumbered the original shard" + IO.FS.writeBinFile ixes (manifestBytes shards) -- Invalid coverage must fail setup, never return successful partial work. -- Reuse the path strings after file writes: the IO FFI must read new bytes. - for invalid in [#[#[consumerAddr]], #[#[consumerAddr, dependencyAddr], #[dependencyAddr]]] do + for invalid in [#[#[consumerAddr]], #[#[consumerAddr, dependencyAddr], #[dependencyAddr]], + #[#[consumerAddr], #[dependencyAddr, dependencyAddr]]] do IO.FS.writeBinFile ixes (manifestBytes invalid) expect (!(← check false 2).isOk) "native setup accepted incomplete/duplicate ownership" + expect (!(← checkSelected (some #[0]) false 2).isOk) + "selection bypassed full-partition coverage or uniqueness checks" -- Both readers must reject malformed trailing manifest data. let trailing := (manifestBytes shards).push 0 IO.FS.writeBinFile ixes trailing expect (!(Ix.Cli.CheckCmd.parseIxesManifest trailing).isOk) "reference parser accepted trailing bytes" expect (!(← check false 2).isOk) "native parser accepted trailing bytes" + expect (!(← checkSelected (some #[0]) false 2).isOk) + "selection bypassed complete manifest parsing" + -- An aggregation tree mentioning only the selected leaf is still invalid: + -- it must cover the ORIGINAL manifest, including all skipped leaves. + let framed := manifestBytes shards + let partialTree := framed.extract 0 (framed.size - 2) ++ + ⟨#[1, 0]⟩ ++ (0 : UInt32).toLEBytes ++ ⟨#[0]⟩ + IO.FS.writeBinFile ixes partialTree + expect (!(Ix.Cli.CheckCmd.parseIxesManifest partialTree).isOk) + "reference parser accepted incomplete aggregation tree" + expect (!(← checkSelected (some #[0]) false 2).isOk) + "selection bypassed whole-manifest aggregation tree validation" IO.FS.writeBinFile ixes (manifestBytes shards) let restored ← IO.ofExcept (← check false 2) expect (restored.failures == 0) "native setup reused a stale path-based result" @@ -98,12 +264,35 @@ public def run : IO Unit := do -- rather than being mistaken for a successful setup/coverage result. let bad : Ixon.Constant := ⟨.axio ⟨false, 0, .ref 99 #[]⟩, #[], #[], #[]⟩ let badAddr := Address.blake3 (Ixon.serConstant bad) + let withBad := env.storeConst badAddr bad + IO.FS.writeBinFile ixe (← IO.ofExcept (Ixon.serEnv withBad)) + IO.FS.writeBinFile ixes (manifestBytes (shards.push #[badAddr])) + let skippedBad ← IO.ofExcept (← checkSelected (some #[0]) false 2) + expect (skippedBad.constants == 1 && skippedBad.shards == 1 && skippedBad.failures == 0) + "native selection executed an unrelated, ill-typed constant" + let selectedBad ← IO.ofExcept (← checkSelected (some #[2]) false 2) + expect (selectedBad.constants == 1 && selectedBad.shards == 1 && selectedBad.failures == 1) + "native selection skipped its selected, ill-typed constant" + -- Unlike an ill-typed declaration, a malformed body invalidates coverage, + -- even when unrelated to the selected shard and correctly content-addressed. + let malformed : ByteArray := ⟨#[0xff]⟩ + let malformedAddr := Address.blake3 malformed + let malformedBody := Ixon.LazyConstant.ofSlice malformed 0 malformed.size + let malformedEnv := { env with consts := env.consts.insert malformedAddr malformedBody } + IO.FS.writeBinFile ixe (← IO.ofExcept (Ixon.serEnv malformedEnv)) + IO.FS.writeBinFile ixes (manifestBytes (shards.push #[malformedAddr])) + expect (!(← checkSelected (some #[0]) false 2).isOk) + "selection bypassed parsing an unreferenced malformed body" + let wrongHashEnv := env.storeConst malformedAddr dependency + IO.FS.writeBinFile ixe (← IO.ofExcept (Ixon.serEnv wrongHashEnv)) + expect (!(← checkSelected (some #[0]) false 2).isOk) + "selection bypassed content-address verification of an unselected constant" IO.FS.writeBinFile ixe (← IO.ofExcept (Ixon.serEnv (({} : Ixon.Env).storeConst badAddr bad))) IO.FS.writeBinFile ixes (manifestBytes #[#[badAddr]]) let rejected ← IO.ofExcept (← check false 1) expect (rejected.constants == 1 && rejected.shards == 1 && rejected.failures == 1) "native full-partition execution accepted an invalid constant" - IO.println "native partition: executor/claim/peak parity and fail-closed setup passed" + IO.println "native partition: full/selected executor/claim/peak parity and fail-closed setup passed" finally IO.FS.removeDirAll dir diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 5beb15798..4f2f492b5 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -29,9 +29,19 @@ namespace IxVMPrim -- Nat arithmetic (try_nat_dispatch / try_nat_binop_addr) public theorem nat_add_lit : 100 + 200 = 300 := rfl +-- Carry from the low limb forces fused add-with-carry on the high limb. +public theorem nat_add_wide_carry : + Nat.add 0xffffffffffffffffffffffffffffffff 0xffffffffffffffffffffffffffffffff = + 0x1fffffffffffffffffffffffffffffffe := rfl public theorem nat_sub_lit : 1000 - 250 = 750 := rfl public theorem nat_mul_lit : Nat.mul 6 7 = 42 := rfl public theorem nat_mul_big : Nat.mul 1000000 1000000 = 1000000000000 := rfl +-- Two maximal limbs force a nonzero carry through each multiplication row. +-- This enters production verify_claim through BOTH generated and bytecode +-- execution, complementing the small arithmetic-only fixture proofs. +public theorem nat_mul_wide_carry : + Nat.mul 0xffffffffffffffffffffffffffffffff 0xffffffffffffffffffffffffffffffff = + 0xfffffffffffffffffffffffffffffffe00000000000000000000000000000001 := rfl public theorem nat_div_lit : Nat.div 100 7 = 14 := rfl public theorem nat_mod_lit : Nat.mod 100 7 = 2 := rfl public theorem nat_succ_lit : Nat.succ 41 = 42 := rfl @@ -352,85 +362,87 @@ private def nameOfString (str : String) : Lean.Name := listed constant fails the suite, so a regression cannot land quietly and an improvement has to be acknowledged by re-pinning. -/ private def kernelCheckEntries : List (String × Nat) := [ - ("HEq", 129_564_490), - ("HEq.rec", 133_835_821), - ("Eq.rec", 133_138_390), - ("Nat", 129_621_511), - ("Nat.add", 170_281_370), - ("Nat.add_comm", 321_324_560), - ("Nat.decEq", 378_272_240), - ("Nat.decLe", 815_724_966), - ("Nat.sub_le_of_le_add", 1_978_749_695), - ("Nat.shiftRight_succ", 1_465_492_882), - ("Trans.mk", 137_285_211), - ("Array.append_assoc", 9_392_514_200), - ("Vector.append", 9_599_238_332), - ("IxVMPrim.nat_add_lit", 212_940_808), - ("IxVMPrim.nat_sub_lit", 227_419_004), - ("IxVMPrim.nat_mul_lit", 203_336_609), - ("IxVMPrim.nat_mul_big", 201_846_122), - ("IxVMPrim.nat_div_lit", 1_429_722_214), - ("IxVMPrim.nat_mod_lit", 1_457_032_266), - ("IxVMPrim.nat_succ_lit", 144_205_846), - ("IxVMPrim.nat_pred_lit", 165_895_387), - ("IxVMPrim.nat_gcd_lit", 2_246_460_709), - ("IxVMPrim.nat_land_lit", 3_702_449_683), - ("IxVMPrim.nat_lor_lit", 3_704_556_317), - ("IxVMPrim.nat_xor_lit", 3_723_893_052), - ("IxVMPrim.nat_shl_lit", 233_004_581), - ("IxVMPrim.nat_shr_lit", 1_445_101_184), - ("IxVMPrim.nat_pow_big", 399_051_503), - ("IxVMPrim.nat_beq_lit", 201_055_250), - ("IxVMPrim.nat_ble_lit", 196_415_590), - ("IxVMPrim.nat_cases_big", 166_089_142), - ("IxVMPrim.nat_dec_le", 833_697_241), - ("IxVMPrim.nat_dec_lt", 845_266_268), - ("IxVMPrim.nat_dec_eq", 417_837_609), - ("IxVMPrim.str_size_lit", 2_577_695_936), - ("IxVMPrim.bv_to_nat_lit", 2_145_356_704), - ("IxVMInd.Even", 206_790_322), - ("IxVMInd.Odd", 206_794_948), - ("IxVMInd.Even.rec", 225_871_765), - ("IxVMInd.Odd.rec", 225_870_836), - ("IxVMInd.IdxTeleN.rec", 160_998_572), - ("IxVMInd.IdxTeleB.rec", 160_996_881), - ("IxVMInd.SoloA.rec", 156_111_821), - ("IxVMInd.SoloB.rec", 156_110_984), - ("IxVMInd.UnsafeSquash", 131_444_123), - ("IxVMInd.Tree", 131_234_444), - ("IxVMInd.Tree.rec", 142_073_111), - ("IxVMInd.DedupM", 134_569_673), - ("IxVMInd.DedupM.rec", 149_126_381), - ("IxVMInd.DepthM", 132_969_322), - ("IxVMInd.DepthM.rec", 144_766_356), - ("String.Internal.append", 2_547_985_001), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_792_209_247), - ("Lean.Syntax.rec", 2_610_636_692), - ("IxVMInd.AuxTie", 324_670_938), - ("IxVMInd.AuxTie.rec", 371_234_512), - ("IxVMInd.HiddenIdx", 130_537_130), - ("IxVMInd.HiddenIdx.rec", 133_953_988), - ("IxVMInd.thmMajorUse", 524_278_831), - ("IxVMInd.partialKRec", 150_274_713), - ("IxVMInd.deepRebase", 221_419_382), - ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_543_958_284), - ("Lean.Widget.TaggedText.rec", 2_580_667_020), - ("Lean.Doc.Part.rec", 2_627_121_877), - ("Lean.Doc.Block.rec", 2_873_716_428), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_540_159), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_184_734), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_211_941), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_211_941), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_211_941), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_835_418), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 144_932_554), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 144_930_972), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_211_941), - ("strOfListFoldSize", 2_863_685_734), - ("strOfListFoldSizeAscii", 2_864_527_734), - ("IxVMPrim.lazy_ble_offset", 234_266_803), - ("IxVMPrim.lazy_unit_cast", 558_018_744), - ("IxVMPrim.sizeof_unit", 160_837_922), + ("HEq", 129_565_168), + ("HEq.rec", 133_846_010), + ("Eq.rec", 133_146_410), + ("Nat", 129_622_237), + ("Nat.add", 170_215_172), + ("Nat.add_comm", 321_215_657), + ("Nat.decEq", 377_647_984), + ("Nat.decLe", 814_641_805), + ("Nat.sub_le_of_le_add", 1_982_894_140), + ("Nat.shiftRight_succ", 1_464_715_066), + ("Trans.mk", 137_297_675), + ("Array.append_assoc", 9_414_745_634), + ("Vector.append", 9_624_596_169), + ("IxVMPrim.nat_add_lit", 212_800_583), + ("IxVMPrim.nat_add_wide_carry", 188_365_576), + ("IxVMPrim.nat_sub_lit", 227_281_066), + ("IxVMPrim.nat_mul_lit", 203_283_296), + ("IxVMPrim.nat_mul_big", 201_789_236), + ("IxVMPrim.nat_mul_wide_carry", 202_083_458), + ("IxVMPrim.nat_div_lit", 1_428_825_019), + ("IxVMPrim.nat_mod_lit", 1_456_132_021), + ("IxVMPrim.nat_succ_lit", 144_192_431), + ("IxVMPrim.nat_pred_lit", 165_858_806), + ("IxVMPrim.nat_gcd_lit", 2_247_029_498), + ("IxVMPrim.nat_land_lit", 3_718_343_691), + ("IxVMPrim.nat_lor_lit", 3_720_478_445), + ("IxVMPrim.nat_xor_lit", 3_739_781_246), + ("IxVMPrim.nat_shl_lit", 232_929_963), + ("IxVMPrim.nat_shr_lit", 1_444_243_654), + ("IxVMPrim.nat_pow_big", 298_517_321), + ("IxVMPrim.nat_beq_lit", 200_982_633), + ("IxVMPrim.nat_ble_lit", 196_338_455), + ("IxVMPrim.nat_cases_big", 166_027_688), + ("IxVMPrim.nat_dec_le", 832_661_979), + ("IxVMPrim.nat_dec_lt", 844_212_231), + ("IxVMPrim.nat_dec_eq", 417_139_222), + ("IxVMPrim.str_size_lit", 2_578_409_620), + ("IxVMPrim.bv_to_nat_lit", 2_145_310_398), + ("IxVMInd.Even", 206_732_263), + ("IxVMInd.Odd", 206_736_899), + ("IxVMInd.Even.rec", 225_757_615), + ("IxVMInd.Odd.rec", 225_756_686), + ("IxVMInd.IdxTeleN.rec", 161_001_626), + ("IxVMInd.IdxTeleB.rec", 160_999_935), + ("IxVMInd.SoloA.rec", 156_110_057), + ("IxVMInd.SoloB.rec", 156_109_220), + ("IxVMInd.UnsafeSquash", 131_445_795), + ("IxVMInd.Tree", 131_228_925), + ("IxVMInd.Tree.rec", 142_062_760), + ("IxVMInd.DedupM", 134_574_554), + ("IxVMInd.DedupM.rec", 149_148_177), + ("IxVMInd.DepthM", 132_971_705), + ("IxVMInd.DepthM.rec", 144_756_748), + ("String.Internal.append", 2_548_585_046), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_794_942_356), + ("Lean.Syntax.rec", 2_611_339_683), + ("IxVMInd.AuxTie", 324_531_930), + ("IxVMInd.AuxTie.rec", 371_135_143), + ("IxVMInd.HiddenIdx", 130_538_188), + ("IxVMInd.HiddenIdx.rec", 133_955_888), + ("IxVMInd.thmMajorUse", 523_141_963), + ("IxVMInd.partialKRec", 150_258_371), + ("IxVMInd.deepRebase", 221_052_103), + ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_554_783_574), + ("Lean.Widget.TaggedText.rec", 2_581_291_326), + ("Lean.Doc.Part.rec", 2_627_809_555), + ("Lean.Doc.Block.rec", 2_874_562_340), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_543_719), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_191_677), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_212_611), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_212_611), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_212_611), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_831_297), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 144_924_615), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 144_923_032), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_212_611), + ("strOfListFoldSize", 2_865_179_586), + ("strOfListFoldSizeAscii", 2_866_025_084), + ("IxVMPrim.lazy_ble_offset", 234_167_030), + ("IxVMPrim.lazy_unit_cast", 557_552_375), + ("IxVMPrim.sizeof_unit", 160_824_361), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Ix/IxVM/ByteHints.lean b/Tests/Ix/IxVM/ByteHints.lean new file mode 100644 index 000000000..7a28fbd46 --- /dev/null +++ b/Tests/Ix/IxVM/ByteHints.lean @@ -0,0 +1,173 @@ +module + +public import Ix.IxVM.Toplevel +public import Tests.Aiur.Common + +/-! +The production arithmetic byte hints must be constant-time, but remain +untrusted advice. Test the real helpers and their real checking callers: +boundary/reference arithmetic, malformed advice, out-of-range inputs, and +small prove/verify cases. No test-only entrypoint enters the production VK. +-/ + +public section + +namespace Tests.Ix.IxVM.ByteHints + +open Aiur LSpec + +private def entries := ⟦ + pub fn carry_hint(x: G) -> (G, G, G) { #split_carry(x) } + pub fn u32_hint(x: G) -> (G, G, G, G) { #split_u32(x) } + pub fn checked_mul(a: U64, b: U64) -> (U64, U64) { u64_mul(a, b) } + pub fn checked_u32(x: G) -> U64 { + let n = klimbs_from_g(x); + match x { + 0 => + assert_eq!(load(n), ListNode.Nil, "zero must stay normalized"); + [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], + _ => + let ListNode.Cons(limb, rest) = load(n); + assert_eq!(load(rest), ListNode.Nil, "u32 must fit one limb"); + limb, + } + } +⟧ + +private def source : Except Global Source.Toplevel := do + let vm ← IxVM.ixVMFull + let vm ← vm.merge entries + pure (vm.prune [`carry_hint, `u32_hint, `checked_mul, `checked_u32]) + +private def bytes (n width : Nat) : Array Aiur.G := + (Array.range width).map fun i => G.ofNat ((n / 256 ^ i) % 256) + +private def boundaryCases : List AiurTestCase := Id.run do + let mut cases := [] + for n in [0, 1, 255, 256, 257, 65535, 65536, 524287] do + cases := cases ++ [.interp `carry_hint #[G.ofNat n] (bytes n 3) s!"carry {n}"] + for n in [0, 1, 255, 256, 65535, 65536, 16777215, 16777216, 4294967295] do + cases := cases ++ [ + .interp `u32_hint #[G.ofNat n] (bytes n 4) s!"u32 hint {n}", + .interp `checked_u32 #[G.ofNat n] (bytes n 8) s!"checked u32 {n}"] + let top := 2 ^ 64 - 1 + let pairs := [(0, top), (1, top), (255, 256), (65535, 65536), + (2 ^ 32, 2 ^ 32), (2 ^ 63, 2), (top, top), + (0x0123456789abcdef, 0xfedcba9876543210)] + for (a, b) in pairs do + cases := cases ++ [.interp `checked_mul (bytes a 8 ++ bytes b 8) + (bytes (a * b) 16) s!"u64 multiply {a} * {b}"] + -- Deterministic varied limbs exercise carry propagation without timing + -- assertions or a dependency on a particular random-number generator. + let mut seed := 0x243f6a8885a308d3 + for i in [:24] do + seed := (seed * 6364136223846793005 + 1442695040888963407) % 2 ^ 64 + let a := seed + seed := (seed * 6364136223846793005 + 1442695040888963407) % 2 ^ 64 + let b := seed + cases := cases ++ [.interp `checked_mul (bytes a 8 ++ bytes b 8) + (bytes (a * b) 16) s!"varied u64 multiply {i}"] + return cases + +/-- Replace only an untrusted helper body, leaving its production checking +caller intact. A missing target is a broken fixture, not a passing rejection. -/ +private def withHint (src : Source.Toplevel) (name : Lean.Name) + (values : Array Aiur.G) : Except String CompiledToplevel := do + if !(src.functions.any fun f => f.name.toName == name) then + throw s!"missing hint {name}" + let functions := src.functions.map fun f => + if f.name.toName == name then + { f with body := .tuple (values.map Source.Term.field) } + else f + { src with functions }.compile + +private def rejects (compiled : CompiledToplevel) (name : Lean.Name) + (input : Array Aiur.G) (label : String) : TestSeq := + match compiled.getFuncIdx name with + | none => test s!"{label}: entrypoint missing" false + | some i => match compiled.bytecode.execute i input default with + | .ok _ => test s!"{label}: must reject" false + | .error _ => test label true + +private def rejectionTests (src : Source.Toplevel) + (compiled : CompiledToplevel) : TestSeq := Id.run do + let mut seq := .done + for n in [2 ^ 32, 2 ^ 32 + 1, gSize.toNat - 1] do + seq := seq ++ rejects compiled `checked_u32 #[G.ofNat n] + s!"checked u32 rejects {n} instead of truncating" + for (hint, advice, entry, input, label) in [ + (`split_carry, #[0, 0, 0], `checked_mul, bytes 1 8 ++ bytes 1 8, + "multiplication rejects wrong in-range carry hint"), + (`split_u32, #[0, 0, 0, 0], `checked_u32, #[1], + "u32 conversion rejects wrong in-range hint")] do + seq := seq ++ withExceptOk s!"{label}: fixture compiles" + (withHint src hint advice) fun altered => rejects altered entry input label + return seq + +/-- Malformed hint bytes must produce a typed execution rejection, including +in release builds with `panic=abort`. Keep the subprocess so a regression to +an abort cannot masquerade as successful rejection or kill the whole suite. -/ +def runOutOfRangeProbe (kind : String) : IO UInt32 := do + let .ok src := source | return 2 + let (hint, advice, entry, input) ← match kind with + | "carry" => pure (`split_carry, #[256, 0, 0], `checked_mul, + bytes 16 8 ++ bytes 16 8) + | "u32" => pure (`split_u32, #[256, 0, 0, 0], `checked_u32, #[256]) + | _ => return 2 + let .ok compiled := withHint src hint advice | return 2 + let some i := compiled.getFuncIdx entry | return 2 + match compiled.bytecode.execute i input default with + | .ok _ => return 0 + | .error e => + IO.eprintln e + return 1 + +private def outOfRangeTests : IO TestSeq := do + let exe ← IO.appPath + let mut seq := .done + for kind in ["carry", "u32"] do + let output ← IO.Process.output { + cmd := "bash" + args := #["-c", "ulimit -c 0; exec \"$@\"", "ixvm-byte-hints", + exe.toString, s!"ixvm-byte-hints-probe={kind}"] } + seq := seq ++ test s!"{kind}: value-correct out-of-range hint byte rejected" + (output.exitCode == 1 && output.stderr.contains + "value 256 out of u8 range [0, 256)") + return seq + +/-- Guard against accidentally putting a recursive Aiur divider back into +either hint. These helpers should each lower to just one native hint op. -/ +private def constantTimeTests (compiled : CompiledToplevel) : TestSeq := Id.run do + let mut seq := test "no repeated-subtraction divider remains reachable" + (compiled.getFuncIdx `divmod_256 == none) + for name in [`split_carry, `split_u32] do + let direct := do + let idx ← compiled.getFuncIdx name + let function ← compiled.bytecode.functions[idx]? + match function.body.ops.toList, function.body.ctrl with + | [.unconstrainedGToBytes 0], .return _ _ => some (!function.constrained) + | _, _ => some false + seq := seq ++ test s!"{name}: one native hint op, no recursion or circuit" + (direct == some true) + return seq + +def run : IO UInt32 := do + let .ok src := source | IO.eprintln "byte-hint fixture merge failed"; return 1 + let .ok env := AiurTestEnv.build (.ok src) + | IO.eprintln "byte-hint fixture compile failed"; return 1 + let tests := constantTimeTests env.compiled ++ rejectionTests src env.compiled + ++ (← outOfRangeTests) + let result ← lspecIO (.ofList [("ixvm-byte-hints", [tests])]) [] + let cases ← lspecEachIO boundaryCases fun tc => pure (env.runTestCase tc) + -- Exercise the actual constraint/lookup pipeline as well as execution. + let top := 2 ^ 64 - 1 + let proofs ← lspecEachIO [ + AiurTestCase.prove `checked_mul (bytes top 8 ++ bytes top 8) + (bytes (top * top) 16) "max-u64 multiplication prove/verify", + AiurTestCase.prove `checked_u32 #[4294967295] (bytes 4294967295 8) + "max-u32 conversion prove/verify"] fun tc => pure (env.runTestCase tc) + return if result == 0 && cases == 0 && proofs == 0 then 0 else 1 + +end Tests.Ix.IxVM.ByteHints + +end diff --git a/Tests/Ix/IxVM/CarryAdd.lean b/Tests/Ix/IxVM/CarryAdd.lean new file mode 100644 index 000000000..37a8be7d2 --- /dev/null +++ b/Tests/Ix/IxVM/CarryAdd.lean @@ -0,0 +1,159 @@ +module + +public import Ix.IxVM.Toplevel +public import Tests.Aiur.Common + +public section + +namespace Tests.Ix.IxVM.CarryAdd + +open Aiur LSpec + +/-! The byte-column invariant behind the fused carry. These Nat lemmas +establish the arithmetic identity and that the sum of the two overflow bits +is a bit. They are not a proof of the whole Aiur compiler or byte gadget. -/ +private theorem carry_column (a b c : Nat) + (ha : a < 256) (hb : b < 256) (hc : c ≤ 1) : + ((a + b) % 256 + c) % 256 = (a + b + c) % 256 ∧ + (a + b) / 256 + ((a + b) % 256 + c) / 256 = (a + b + c) / 256 ∧ + (a + b) / 256 + ((a + b) % 256 + c) / 256 ≤ 1 := by + omega + +private theorem product_high_bound (a b : Nat) + (ha : a < 2^64) (hb : b < 2^64) : a * b / 2^64 ≤ 2^64 - 2 := by + have h : a * b ≤ (2^64 - 1) * (2^64 - 1) := + Nat.mul_le_mul (by omega) (by omega) + omega + +private theorem high_carry_fits (hi c : Nat) + (hhi : hi ≤ 2^64 - 2) (hc : c ≤ 1) : hi + c < 2^64 := by omega + +private def fixtures := ⟦ + pub fn inc(a: U64) -> (U64, U8) { u64_succ_carry(a) } + pub fn inc_legacy(a: U64) -> (U64, U8) { + u64_add(a, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]) + } + pub fn adc(a: U64, b: U64) -> (U64, U8) { u64_add_carry_one(a, b) } + pub fn adc_legacy(a: U64, b: U64) -> (U64, U8) { + let (sum, c1) = u64_add(a, b); + let (out, c2) = u64_add(sum, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + (out, u8_from_field_unsafe(to_field(c1) + to_field(c2))) + } + -- Exercise the production carry dispatch, not a copy of its conditionals. + pub fn limb_add(a: U64, b: U64, carry: G) -> (U64, U8) { + let nil = store(ListNode.Nil); + let out = klimbs_add_carry(store(ListNode.Cons(a, nil)), + store(ListNode.Cons(b, nil)), carry); + let ListNode.Cons(sum, rest) = load(out); + match load(rest) { + ListNode.Nil => (sum, 0u8), + ListNode.Cons(top, tail) => + assert_eq!(top, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + assert_eq!(load(tail), ListNode.Nil); + (sum, 1u8), + } + } + pub fn empty_add(carry: G) -> G { + let nil = store(ListNode.Nil); + match load(klimbs_add_carry(nil, nil, carry)) { + ListNode.Nil => 0, + ListNode.Cons(limb, _) => to_field(limb[0]), + } + } + pub fn right_empty_add(carry: G) -> G { + let nil = store(ListNode.Nil); + let one = store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], nil)); + match load(klimbs_add_carry(one, nil, carry)) { + ListNode.Nil => 0, + ListNode.Cons(limb, _) => to_field(limb[0]), + } + } +⟧ + +private def source : Except Global Source.Toplevel := do + let vm ← IxVM.ixVMFull + let vm ← vm.merge fixtures + pure (vm.prune [`inc, `inc_legacy, `adc, `adc_legacy, `limb_add, + `empty_add, `right_empty_add]) + +private def radix : Nat := 2^64 +private def bytes (n : Nat) : Array Aiur.G := + (Array.range 8).map fun i => G.ofNat ((n / 256^i) % 256) +private def output (n : Nat) : Array Aiur.G := bytes n ++ #[G.ofNat (n / radix)] + +private def cases : List AiurTestCase := Id.run do + let top := radix - 1 + let mut result := [] + -- Carry stops at each possible byte, plus full-u64 overflow. + for k in [:9] do + let a := 256^k - 1 + for entry in [`inc, `inc_legacy] do + result := result ++ [.interp entry (bytes a) (output (a + 1)) s!"{entry} carry chain {k}"] + let mut pairs := [(0, 0), (0, top), (top, 0), (top, top), (255, 255), + (255, 0), (256, 255), (2^32 - 1, 2^32 - 1), (2^63, 2^63 - 1)] + for k in [1:8] do pairs := pairs ++ [(256^k - 1, 1), (256^k - 2, 1)] + let mut seed := 0x243f6a8885a308d3 + for _ in [:24] do + seed := (seed * 6364136223846793005 + 1442695040888963407) % radix + let a := seed + seed := (seed * 6364136223846793005 + 1442695040888963407) % radix + pairs := pairs ++ [(a, seed)] + for ((a, b), i) in pairs.zipIdx do + for entry in [`adc, `adc_legacy] do + result := result ++ [.interp entry (bytes a ++ bytes b) (output (a + b + 1)) + s!"{entry} pair {i}"] + for carry in [0, 1] do + result := result ++ [.interp `limb_add (bytes a ++ bytes b ++ #[G.ofNat carry]) + (output (a + b + carry)) s!"limb add pair {i}, carry {carry}"] + for carry in [0, 1] do + result := result ++ [ + .interp `empty_add #[G.ofNat carry] #[G.ofNat carry] s!"empty add carry {carry}", + .interp `right_empty_add #[G.ofNat carry] #[G.ofNat (1 + carry)] + s!"right-empty add carry {carry}"] + return result + +private def structuralTests (env : AiurTestEnv) : TestSeq := Id.run do + let mut seq := .done + for (name, inputs, adds) in [(`u64_succ_carry, 8, 8), (`u64_add_carry_one, 16, 16)] do + let valid := do + let idx ← env.compiled.getFuncIdx name + let function ← env.compiled.bytecode.functions[idx]? + let checkedAdds := function.body.ops.foldl (fun n op => match op with + | .u8Add _ _ => n + 1 | _ => n) 0 + return function.layout.inputSize == inputs && checkedAdds == adds && function.constrained + seq := seq ++ test s!"{name}: narrow key and {adds} constrained byte adds" + (valid == some true) + return seq + +private def rejectBadCarry (env : AiurTestEnv) : TestSeq := Id.run do + let mut seq := .done + for carry in [2, 255, gSize.toNat - 1] do + for (entry, inputPrefix) in [(`limb_add, bytes 0 ++ bytes 0), + (`empty_add, #[]), (`right_empty_add, #[])] do + match env.compiled.getFuncIdx entry with + | none => seq := seq ++ test s!"{entry}: missing rejection fixture" false + | some idx => + let result := env.compiled.bytecode.execute idx (inputPrefix ++ #[G.ofNat carry]) default + seq := seq ++ test s!"{entry} rejects non-bit carry {carry}" (!result.isOk) + return seq + +def run : IO UInt32 := do + let env ← IO.ofExcept <| (AiurTestEnv.build source).mapError + (fun e => s!"carry-add fixture build failed: {e}") + let basic ← lspecEachIO cases fun tc => pure (env.runTestCase tc) + let checks ← lspecIO (.ofList [("ixvm-carry-add", + [structuralTests env ++ rejectBadCarry env])]) [] + let top := radix - 1 + let proofs ← lspecEachIO [ + AiurTestCase.prove `inc (bytes top) (output radix) "checked increment overflow prove/verify", + AiurTestCase.prove `adc (bytes top ++ bytes top) (output (2 * top + 1)) + "fused add maximal carry prove/verify", + AiurTestCase.prove `limb_add (bytes top ++ bytes 0 ++ #[0]) (output top) + "zero-carry dispatch prove/verify", + AiurTestCase.prove `limb_add (bytes top ++ bytes top ++ #[1]) (output (2 * top + 1)) + "one-carry dispatch prove/verify"] fun tc => pure (env.runTestCase tc) + return if basic == 0 && checks == 0 && proofs == 0 then 0 else 1 + +end Tests.Ix.IxVM.CarryAdd + +end diff --git a/Tests/Ix/IxVM/FusedMul.lean b/Tests/Ix/IxVM/FusedMul.lean new file mode 100644 index 000000000..058b7ea69 --- /dev/null +++ b/Tests/Ix/IxVM/FusedMul.lean @@ -0,0 +1,238 @@ +module + +public import Ix.IxVM.Toplevel +public import Tests.Aiur.Common + +public section +namespace Tests.Ix.IxVM.FusedMul +open Aiur LSpec + +/-! Producer/consumer fusion, parameterized by the unchanged arithmetic +steps. Equality is of exact lists, not only their numeric interpretation. +This is not a proof of the Aiur compiler or underlying arithmetic gadgets. -/ +private def produce (step : α → μ → β × μ) (finish : μ → List β) : + List α → μ → List β + | [], carry => finish carry + | x :: xs, carry => let (out, next) := step x carry + out :: produce step finish xs next + +private def consume (step : β → β → ν → β × ν) (finish : List β → ν → List β) : + List β → List β → ν → List β + | [], ys, carry => finish ys carry + | xs, [], carry => finish xs carry + | x :: xs, y :: ys, carry => let (out, next) := step x y carry + out :: consume step finish xs ys next + +private def fused (mul : α → μ → β × μ) (endMul : μ → List β) + (add : β → β → ν → β × ν) (endAdd : List β → ν → List β) : + List α → List β → μ → ν → List β + | [], acc, mc, ac => consume add endAdd acc (endMul mc) ac + | x :: xs, [], mc, ac => consume add endAdd [] (produce mul endMul (x :: xs) mc) ac + | x :: xs, y :: ys, mc, ac => + let (digit, nextMc) := mul x mc + let (out, nextAc) := add y digit ac + out :: fused mul endMul add endAdd xs ys nextMc nextAc + +private theorem fused_eq_produce_consume (mul : α → μ → β × μ) (endMul : μ → List β) + (add : β → β → ν → β × ν) (endAdd : List β → ν → List β) + (xs : List α) (acc : List β) (mc : μ) (ac : ν) : + fused mul endMul add endAdd xs acc mc ac = + consume add endAdd acc (produce mul endMul xs mc) ac := by + induction xs generalizing acc mc ac with + | nil => rfl + | cons x xs ih => cases acc <;> simp [fused, produce, consume, ih] + +private def fixtures := ⟦ + -- Frozen pre-fusion outer loop. This remains test-only after production + -- adopts fusion; it still shares the unchanged arithmetic and row helpers. + fn legacy_fma_outer(a: KLimbs, b: KLimbs, acc: KLimbs, shift: G) -> KLimbs { + match load(a) { + ListNode.Nil => acc, + ListNode.Cons(a_limb, rest) => + let prod = klimbs_mul_single(a_limb, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + let shifted = klimbs_shl_limbs(prod, shift); + let next = klimbs_add(acc, shifted); + legacy_fma_outer(rest, b, next, shift + 1), + } + } + fn fma_read(n: G, offset: G) -> KLimbs { + match n { + 0 => store(ListNode.Nil), + _ => let [b0, b1, b2, b3, b4, b5, b6, b7] = io_read(0, offset, 8); + let (c0, c1) = u8_range_check(b0, b1); + let (c2, c3) = u8_range_check(b2, b3); + let (c4, c5) = u8_range_check(b4, b5); + let (c6, c7) = u8_range_check(b6, b7); + store(ListNode.Cons([c0, c1, c2, c3, c4, c5, c6, c7], fma_read(n - 1, offset + 8))), + } + } + fn fma_write(xs: KLimbs) { + match load(xs) { + ListNode.Nil => (), + ListNode.Cons(limb, rest) => + let [b0, b1, b2, b3, b4, b5, b6, b7] = limb; + io_write(1, [to_field(b0), to_field(b1), to_field(b2), to_field(b3), + to_field(b4), to_field(b5), to_field(b6), to_field(b7)]); + fma_write(rest), + } + } + pub fn fma_row(mode: G, a: U64, mc: U64, ac: G, n: G, m: G) { + let b = fma_read(n, 0); + let acc = fma_read(m, n * 8); + let result = match mode { + 0 => klimbs_mul_acc_row(a, b, acc, mc, ac), + 1 => klimbs_add_carry(acc, klimbs_mul_single(a, b, mc), ac), + }; + fma_write(result) + } + pub fn fma_shift(mode: G, a: U64, shift: G, n: G, m: G) { + let b = fma_read(n, 0); + let acc = fma_read(m, n * 8); + let result = match mode { + 0 => klimbs_mul_acc_shift(a, b, acc, shift), + 1 => klimbs_add(acc, klimbs_shl_limbs( + klimbs_mul_single(a, b, [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]), shift)), + }; + fma_write(result) + } + pub fn fma_product(mode: G, n: G, m: G) { + let a = fma_read(n, 0); + let b = fma_read(m, n * 8); + let result = match mode { + 0 => klimbs_mul(a, b), + 1 => legacy_fma_outer(a, b, store(ListNode.Nil), 0), + }; + fma_write(result) + } +⟧ + +private def source : Except Global Source.Toplevel := do + let vm ← IxVM.ixVMFull + let vm ← vm.merge fixtures + pure (vm.prune [`fma_row, `fma_shift, `fma_product]) + +private def radix : Nat := 2^64 +private def bytes (n : Nat) : Array Aiur.G := (Array.range 8).map fun i => G.ofNat ((n / 256^i) % 256) +private def data (xs : List Nat) : Array Aiur.G := xs.foldl (fun acc x => acc ++ bytes x) #[] +private def rowRef (a : Nat) : List Nat → Nat → List Nat + | [], carry => if carry == 0 then [] else [carry] + | b :: bs, carry => let n := a * b + carry + n % radix :: rowRef a bs (n / radix) +private def succRef : List Nat → List Nat + | [] => [1] + | x :: xs => if x + 1 < radix then (x + 1) :: xs else 0 :: succRef xs +private def addRef : List Nat → List Nat → Nat → List Nat + | [], ys, c => if c == 0 then ys else succRef ys + | xs, [], c => if c == 0 then xs else succRef xs + | x :: xs, y :: ys, c => let n := x + y + c + n % radix :: addRef xs ys (n / radix) +private def productRef (a b : List Nat) : List Nat := + ((a.foldl fun (acc, shift) x => + (addRef acc (List.replicate shift 0 ++ rowRef x b 0) 0, shift + 1)) ([], 0)).1 +private def varied (n : Nat) : List Nat := Id.run do + let mut seed := 0x243f6a8885a308d3 + let mut xs := [] + for _ in [:n] do + seed := (seed * 6364136223846793005 + 1442695040888963407) % radix + xs := seed :: xs + return xs + +private def fixture (name : Lean.Name) (mode : Nat) (args : Array Aiur.G) + (input expected : List Nat) (label : String) : AiurTestCase := + let io : IOBuffer := { data := ({} : Std.HashMap _ _).insert 0 (data input), map := {} } + { functionName := name, label := s!"{label} ({mode})", input := #[G.ofNat mode] ++ args, + inputIOBuffer := io, expectedIOBuffer := if expected.isEmpty then io else + { io with data := io.data.insert 1 (data expected) }, withProof := false } +private def rowCase (mode a mc ac : Nat) (b acc : List Nat) (label : String) : AiurTestCase := + fixture `fma_row mode (bytes a ++ bytes mc ++ #[G.ofNat ac, G.ofNat b.length, G.ofNat acc.length]) + (b ++ acc) (addRef acc (rowRef a b mc) ac) label +private def shiftCase (mode a shift : Nat) (b acc : List Nat) (label : String) : AiurTestCase := + fixture `fma_shift mode (bytes a ++ #[G.ofNat shift, G.ofNat b.length, G.ofNat acc.length]) + (b ++ acc) (addRef acc (List.replicate shift 0 ++ rowRef a b 0) 0) label +private def productCase (mode : Nat) (a b : List Nat) (label : String) : AiurTestCase := + fixture `fma_product mode #[G.ofNat a.length, G.ofNat b.length] (a ++ b) (productRef a b) label + +private def cases : List AiurTestCase := Id.run do + let top := radix - 1 + let mut cases := [] + let lists := [[], [0], [0, 0], [1], [top], [top, top], [top, 0, 0], varied 5] + for (b, i) in lists.zipIdx do + for (acc, j) in lists.zipIdx do + for (a, mc) in [(0, 0), (1, top), (top, top)] do + for ac in [0, 1] do + for mode in [0, 1] do + cases := cases ++ [rowCase mode a mc ac b acc s!"row {i}/{j}/{a}/{mc}/{ac}"] + for shift in [0, 1, 3, 6] do + for mode in [0, 1] do + cases := cases ++ [shiftCase mode top shift b acc s!"shift {i}/{j}/{shift}"] + for mode in [0, 1] do + cases := cases ++ [productCase mode b acc s!"product {i}/{j}"] + return cases + +private def execute (env : AiurTestEnv) (tc : AiurTestCase) : Except String (Array QueryCount) := do + let some idx := env.compiled.getFuncIdx tc.functionName | throw "fixture entry missing" + let (out, io, qc) ← env.compiled.bytecode.execute idx tc.input tc.inputIOBuffer + unless out == tc.expectedOutput && io == tc.expectedIOBuffer do throw s!"wrong result: {tc.label}" + return qc + +private def stats (env : AiurTestEnv) (qc : Array QueryCount) : Except String (Nat × Nat × Float) := do + let some i := env.compiled.bytecode.memorySizes.findIdx? (· == 10) | throw "limb circuit missing" + let some mem := qc[env.compiled.bytecode.functions.size + i]? | throw "limb count missing" + let rows := qc.foldl (fun n q => n + q.uniqueRows) 0 + return (mem.uniqueRows, rows, (computeStats env.compiled qc env.shapes).totalFftCost) + +private def scaling (env : AiurTestEnv) : IO TestSeq := do + let mut seq := .done + for (n, m) in [(1, 32), (4, 4), (8, 32), (32, 8), (16, 16), (32, 32)] do + for repeated in [false, true] do + let a := if repeated then List.replicate n (radix - 1) else varied n + let b := varied m + let result := do + let now ← stats env (← execute env (productCase 0 a b "fused scaling")) + let old ← stats env (← execute env (productCase 1 a b "legacy scaling")) + return (now, old) + match result with + | .error e => seq := seq ++ test s!"scaling {n}/{m}: {e}" false + | .ok ((mem, rows, fft), (oldMem, oldRows, oldFft)) => + IO.println s!"[fused-mul] {n}x{m} repeated={repeated} limbs={mem}/{oldMem} rows={rows}/{oldRows} FFT={fft}/{oldFft} (new/old)" + seq := seq ++ test s!"{n}x{m}/{repeated}: exact output agrees with Nat model" true + ++ test s!"{n}x{m}/{repeated}: no extra limb-list nodes" (mem <= oldMem) + ++ test s!"{n}x{m}/{repeated}: fewer total query rows" (rows < oldRows) + if repeated then + -- The old pipeline shares whole repeated product rows. Fusion + -- retains fewer records but can have slightly wider hot circuits. + seq := seq ++ test s!"{n}x{m}: repeated-input FFT regression <= 0.5%" (fft <= oldFft * 1.005) + else + seq := seq ++ test s!"{n}x{m}: varied-input FFT improves" (fft < oldFft) + if n > 1 then + seq := seq ++ test s!"{n}x{m}: varied-input limb nodes shrink" (mem < oldMem) + return seq + +private def invalidCarryTests (env : AiurTestEnv) : TestSeq := Id.run do + let mut seq := .done + for ac in [2, 255, gSize.toNat - 1] do + for (b, acc) in [([], []), ([1], []), ([], [1]), ([1], [1])] do + for mode in [0, 1] do + let tc := rowCase mode 1 0 ac b acc "invalid addition carry" + let some idx := env.compiled.getFuncIdx tc.functionName + | return test "carry fixture entry missing" false + let result := env.compiled.bytecode.execute idx tc.input tc.inputIOBuffer + seq := seq ++ test s!"{mode}: non-bit carry {ac}, lengths {b.length}/{acc.length} rejected" + (!result.isOk) + return seq + +def run : IO UInt32 := do + let env ← IO.ofExcept (AiurTestEnv.build source) + let basic ← lspecEachIO cases fun tc => pure (env.runTestCase tc) + let measured ← scaling env + let cost ← lspecIO (.ofList [("ixvm-fused-mul", [measured, invalidCarryTests env])]) [] + let top := radix - 1 + let proofs := [ + { rowCase 0 top top 1 [top, top] [top, top, top] "fused carries proof" with withProof := true }, + { shiftCase 0 top 3 [top, top] [top] "fused shift proof" with withProof := true }, + { productCase 0 [top, top] [top, top] "fused product proof" with withProof := true }] + let proved ← lspecEachIO proofs fun tc => pure (env.runTestCase tc) + return if basic == 0 && cost == 0 && proved == 0 then 0 else 1 + +end Tests.Ix.IxVM.FusedMul +end diff --git a/Tests/Ix/IxVM/LimbMul.lean b/Tests/Ix/IxVM/LimbMul.lean new file mode 100644 index 000000000..5a6102c77 --- /dev/null +++ b/Tests/Ix/IxVM/LimbMul.lean @@ -0,0 +1,283 @@ +module + +public import Ix.IxVM.Toplevel +public import Tests.Aiur.Common + +public section + +namespace Tests.Ix.IxVM.LimbMul + +open Aiur LSpec + +/-! A list-level equivalence proof, parameterized by the unchanged arithmetic +step and final-carry rule. This proves the construction transformation, not +the whole Aiur compiler/executor or the arithmetic gadgets. -/ + +private def prefixRow (step : α → β → α × β) (finish : β → List α) : + List α → β → List α → List α + | [], carry, acc => acc ++ finish carry + | x :: xs, carry, acc => + let (limb, next) := step x carry + prefixRow step finish xs next (acc ++ [limb]) + +private def consRow (step : α → β → α × β) (finish : β → List α) : + List α → β → List α + | [], carry => finish carry + | x :: xs, carry => + let (limb, next) := step x carry + limb :: consRow step finish xs next + +private theorem prefixRow_eq_append_consRow + (step : α → β → α × β) (finish : β → List α) + (xs : List α) (carry : β) (acc : List α) : + prefixRow step finish xs carry acc = acc ++ consRow step finish xs carry := by + induction xs generalizing carry acc with + | nil => rfl + | cons x xs ih => simp [prefixRow, consRow, ih, List.append_assoc] + +private def fixtures := ⟦ + -- Frozen pre-optimization implementation, sharing the REAL arithmetic + -- helpers. Keep this test-only; it must never enter the production VK. + fn legacy_row(a: U64, b: KLimbs, carry: U64, acc: KLimbs) -> KLimbs { + match load(b) { + ListNode.Nil => + match u64_is_zero(carry) { + 1 => acc, + 0 => list_snoc(acc, carry), + }, + ListNode.Cons(limb, rest) => + let (lo, hi) = u64_mul(a, limb); + let (sum, carry_out) = u64_add(lo, carry); + let (next, _) = u64_add(hi, + [carry_out, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + legacy_row(a, rest, next, list_snoc(acc, sum)), + } + } + + -- Isolate carry specialization from the earlier cons-vs-snoc change: + -- this is the linear row builder immediately BEFORE carry specialization. + fn before_carry_row(a: U64, b: KLimbs, carry: U64) -> KLimbs { + match load(b) { + ListNode.Nil => match u64_is_zero(carry) { + 1 => store(ListNode.Nil), + 0 => store(ListNode.Cons(carry, store(ListNode.Nil))), + }, + ListNode.Cons(limb, rest) => + let (lo, hi) = u64_mul(a, limb); + let (sum, carry_out) = u64_add(lo, carry); + let (next, _) = u64_add(hi, + [carry_out, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + store(ListNode.Cons(sum, before_carry_row(a, rest, next))), + } + } + + fn read_limbs(n: G, offset: G) -> KLimbs { + match n { + 0 => store(ListNode.Nil), + _ => + let [b0, b1, b2, b3, b4, b5, b6, b7] = io_read(0, offset, 8); + let (c0, c1) = u8_range_check(b0, b1); + let (c2, c3) = u8_range_check(b2, b3); + let (c4, c5) = u8_range_check(b4, b5); + let (c6, c7) = u8_range_check(b6, b7); + store(ListNode.Cons([c0, c1, c2, c3, c4, c5, c6, c7], + read_limbs(n - 1, offset + 8))), + } + } + + fn write_limbs(xs: KLimbs) { + match load(xs) { + ListNode.Nil => (), + ListNode.Cons(limb, rest) => + let [b0, b1, b2, b3, b4, b5, b6, b7] = limb; + io_write(1, [to_field(b0), to_field(b1), to_field(b2), to_field(b3), + to_field(b4), to_field(b5), to_field(b6), to_field(b7)]); + write_limbs(rest), + } + } + + pub fn row_linear(a: U64, carry: U64, n: G) { + write_limbs(klimbs_mul_single(a, read_limbs(n, 0), carry)) + } + pub fn row_legacy(a: U64, carry: U64, n: G) { + write_limbs(legacy_row(a, read_limbs(n, 0), carry, store(ListNode.Nil))) + } + pub fn row_before_carry(a: U64, carry: U64, n: G) { + write_limbs(before_carry_row(a, read_limbs(n, 0), carry)) + } + pub fn product(n: G, m: G) { + let a = read_limbs(n, 0); + let b = read_limbs(m, n * 8); + write_limbs(klimbs_normalize(klimbs_mul(a, b))) + } +⟧ + +private def source : Except Global Source.Toplevel := do + let vm ← IxVM.ixVMFull + let vm ← vm.merge fixtures + pure (vm.prune [`row_linear, `row_legacy, `row_before_carry, `product]) + +private def radix : Nat := 2 ^ 64 +private def limbBytes (n : Nat) : Array Aiur.G := + (Array.range 8).map fun i => G.ofNat ((n / 256 ^ i) % 256) +private def limbData (xs : List Nat) : Array Aiur.G := + xs.foldl (fun data x => data ++ limbBytes x) #[] +private def value (xs : List Nat) : Nat := xs.foldr (fun x v => x + radix * v) 0 + +private def rowRef (a : Nat) : List Nat → Nat → List Nat + | [], carry => if carry == 0 then [] else [carry] + | x :: xs, carry => + let p := a * x + carry + (p % radix) :: rowRef a xs (p / radix) + +private def varied (n : Nat) : List Nat := Id.run do + let mut seed := 0x243f6a8885a308d3 + let mut xs := [] + for _ in [:n] do + seed := (seed * 6364136223846793005 + 1442695040888963407) % radix + xs := seed :: xs + return xs + +private def inputIo (xs : List Nat) : IOBuffer := + { data := ({} : Std.HashMap _ _).insert 0 (limbData xs), map := {} } + +private def outputIo (input : IOBuffer) (xs : List Nat) : IOBuffer := + if xs.isEmpty then input else + { input with data := input.data.insert 1 (limbData xs) } + +private def rowCase (entry : Lean.Name) (a carry : Nat) (xs : List Nat) + (label : String) : AiurTestCase := + let io := inputIo xs + { functionName := entry, label + input := limbBytes a ++ limbBytes carry ++ #[G.ofNat xs.length] + inputIOBuffer := io, expectedIOBuffer := outputIo io (rowRef a xs carry) + withProof := false } + +private def productCase (a b : List Nat) (label : String) : AiurTestCase := + let io := inputIo (a ++ b) + let p := value a * value b + let output := (List.range (a.length + b.length)).map + (fun i => (p / radix ^ i) % radix) + let normalized := (output.reverse.dropWhile (· == 0)).reverse + { functionName := `product, label + input := #[G.ofNat a.length, G.ofNat b.length] + inputIOBuffer := io, expectedIOBuffer := outputIo io normalized + withProof := false } + +private def rowCases : List AiurTestCase := Id.run do + let top := radix - 1 + let cases := [(0, 0, []), (top, 0, []), (top, top, []), + (0, 0, [0, 0, 0]), (0, top, [top, 0, 0]), + (1, 0, [7, 0, 0]), (top, top, [top, top, top]), + (2 ^ 32, 1, [2 ^ 32, 0, top]), (top - 2, 7, varied 12)] + let mut result := [] + for ((a, carry, xs), i) in cases.zipIdx do + for entry in [`row_linear, `row_legacy, `row_before_carry] do + result := result ++ [rowCase entry a carry xs s!"{entry} boundary {i}"] + return result + +private def productCases : List AiurTestCase := Id.run do + let top := radix - 1 + let mut result := [] + for ((a, b), i) in [([], [top]), ([top], []), ([0, 0], [top, 0]), + ([1], [top, 0, 0]), ([0, 1], [0, 1]), + ([top, top], [top, top]), (varied 4, varied 7)].zipIdx do + result := result ++ [productCase a b s!"full product {i}"] + return result + +private def execute (env : AiurTestEnv) (tc : AiurTestCase) : + Except String (Array QueryCount) := do + let some idx := env.compiled.getFuncIdx tc.functionName + | throw "missing row entry" + let (out, io, qc) ← env.compiled.bytecode.execute idx tc.input tc.inputIOBuffer + if out != tc.expectedOutput || io != tc.expectedIOBuffer then + throw s!"wrong result for {tc.label}" + return qc + +private def limbRows (compiled : CompiledToplevel) (qc : Array QueryCount) : + Except String Nat := do + let some i := compiled.bytecode.memorySizes.findIdx? (· == 10) + | throw "limb memory circuit missing" + let some count := qc[compiled.bytecode.functions.size + i]? + | throw "limb memory query count missing" + return count.uniqueRows + +private def scalingTests (env : AiurTestEnv) : IO TestSeq := do + let mut seq := .done + for n in [16, 32, 64, 128, 256, 512] do + let a := radix - 3 + let xs := varied n + let comparison := do + let linear ← execute env (rowCase `row_linear a 7 xs s!"linear {n}") + let legacy ← execute env (rowCase `row_legacy a 7 xs s!"legacy {n}") + let l ← limbRows env.compiled linear + let old ← limbRows env.compiled legacy + return (l, old) + match comparison with + | .error e => seq := seq ++ test s!"row scaling {n}: {e}" false + | .ok (linear, legacy) => + IO.println s!"[limb-row] n={n} memory rows: linear={linear} legacy={legacy}" + seq := seq ++ test s!"{n} limbs: exact outputs agree with Nat model" true + ++ test s!"{n} limbs: input + output use at most 2*n+2 memory rows" + (linear <= 2 * n + 2) + ++ test s!"{n} limbs: legacy fixture exposes quadratic prefix copying" + (legacy >= n * (n + 1) / 2) + return seq + +/-- Uncompressed-equivalent argument/result storage for the hot addition helpers. +The increment has 8 input + 9 output fields; generic/fused addition has +16 + 9. This is a row-count model, not the byte-encoded retained payload; +it excludes table/multiplicity overhead and is NOT total RSS. -/ +private def additionPayload (compiled : CompiledToplevel) (qc : Array QueryCount) : + Except String (Nat × Nat) := do + let some add := compiled.getFuncIdx `u64_add | throw "u64_add missing" + let some addCount := qc[add]? | throw "u64_add count missing" + let mut words := addCount.uniqueRows * 25 + for (name, width) in [(`u64_succ_carry, 17), (`u64_add_carry_one, 25)] do + if let some idx := compiled.getFuncIdx name then + let some count := qc[idx]? | throw s!"{name} count missing" + words := words + count.uniqueRows * width + return (addCount.uniqueRows, words * 8) + +private def carrySavingsTests (env : AiurTestEnv) : IO TestSeq := do + let mut seq := .done + for n in [16, 64, 256, 512] do + let comparison := do + let xs := varied n + let now ← execute env (rowCase `row_linear (radix - 3) 7 xs s!"carry optimized {n}") + let old ← execute env (rowCase `row_before_carry (radix - 3) 7 xs s!"carry baseline {n}") + let current ← additionPayload env.compiled now + let previous ← additionPayload env.compiled old + let currentFft := (computeStats env.compiled now env.shapes).totalFftCost + let previousFft := (computeStats env.compiled old env.shapes).totalFftCost + return (current, previous, currentFft, previousFft) + match comparison with + | .error e => seq := seq ++ test s!"carry savings {n}: {e}" false + | .ok ((rows, payload), (oldRows, oldPayload), fft, oldFft) => + IO.println s!"[carry-row] n={n} u64_add rows={rows}/{oldRows}, uncompressed-equivalent addition payload={payload}/{oldPayload} bytes, FFT={fft}/{oldFft} (new/old)" + seq := seq ++ test s!"{n} limbs: old/new exact outputs match Nat reference" true + ++ test s!"{n} limbs: at least half the generic u64_add rows removed" (rows * 2 <= oldRows) + ++ test s!"{n} limbs: uncompressed-equivalent hot addition payload shrank" (payload < oldPayload) + ++ test s!"{n} limbs: row FFT cost improved" (fft < oldFft) + return seq + +def run : IO UInt32 := do + let .ok env := AiurTestEnv.build source + | IO.eprintln "limb-multiplication fixture build failed"; return 1 + let basic ← lspecEachIO (rowCases ++ productCases) fun tc => + pure (env.runTestCase tc) + let scaling ← scalingTests env + let carrySavings ← carrySavingsTests env + let scaleResult ← lspecIO (.ofList [("ixvm-limb-mul", [scaling, carrySavings])]) [] + let top := radix - 1 + let proofs := [ + { rowCase `row_linear top top [top, top] "row carry prove/verify" with + withProof := true }, + { productCase [top, top] [top, top] "multi-limb product prove/verify" with + withProof := true }] + let proofResult ← lspecEachIO proofs fun tc => pure (env.runTestCase tc) + return if basic == 0 && scaleResult == 0 && proofResult == 0 then 0 else 1 + +end Tests.Ix.IxVM.LimbMul + +end diff --git a/Tests/Ix/IxVM/SubstProjection.lean b/Tests/Ix/IxVM/SubstProjection.lean new file mode 100644 index 000000000..450261d80 --- /dev/null +++ b/Tests/Ix/IxVM/SubstProjection.lean @@ -0,0 +1,337 @@ +module + +public import Ix.IxVM.Toplevel +public import Tests.Aiur.Common + +public section +namespace Tests.Ix.IxVM.SubstProjection +open Aiur LSpec + +/-- Frozen pre-projection walker. It shares lifting/lowering, not the new +prefix summary or projected recursion. Test-only, pruned from production. -/ +private def reference := ⟦ + fn legacy_inst_many(e: KExpr, substs: List‹KExpr›, depth: G) -> KExpr { + let n = list_length(substs); + match n { + 0 => e, + _ => + let l = expr_lbr(e); + match memo_u32_less_than(depth, l) { + 0 => e, + 1 => + match has_bvar_in_range(e, depth, depth + n) { + 1 => legacy_inst_many_walk(e, substs, depth), + _ => expr_lower(e, n, depth + n), + }, + }, + } + } + + -- Cold BVar arm of `legacy_inst_many_walk`, split into its own circuit so the + -- hot App/Lam/… walk stays narrow (the `list_length` / `list_lookup` / + -- `expr_lift` machinery only charges the BVar rows). Mirror the hot/cold + -- split pattern used for `address_eq` / `whnf_with_spine`. + -- + -- The walk invariant gives `lbr(BVar i) = i + 1 > depth`, i.e. + -- `i ≥ depth`, so the window test reduces to one comparison on the + -- offset. A sub-`depth` index (invariant violation) wraps in the field + -- and fails the u32 range decomposition — no silent path. + fn legacy_inst_many_bvar(i: G, substs: List‹KExpr›, depth: G) -> KExpr { + let n = list_length(substs); + let ofs = i - depth; + match memo_u32_less_than(ofs, n) { + 1 => expr_lift(list_lookup(substs, ofs), depth, 0), + 0 => store(KExprNode.BVar(i - n)), + } + } + + fn legacy_inst_many_walk(e: KExpr, substs: List‹KExpr›, depth: G) -> KExpr { + match load(e) { + KExprNode.BVar(i) => legacy_inst_many_bvar(i, substs, depth), + KExprNode.Srt(l) => store(KExprNode.Srt(l)), + KExprNode.Const(idx, lvls) => store(KExprNode.Const(idx, lvls)), + KExprNode.App(f, a) => + store(KExprNode.App( + legacy_inst_many(f, substs, depth), + legacy_inst_many(a, substs, depth))), + KExprNode.Lam(ty, body) => + store(KExprNode.Lam( + legacy_inst_many(ty, substs, depth), + legacy_inst_many(body, substs, depth + 1))), + KExprNode.Forall(ty, body) => + store(KExprNode.Forall( + legacy_inst_many(ty, substs, depth), + legacy_inst_many(body, substs, depth + 1))), + KExprNode.Let(ty, val, body) => + legacy_inst_many_let(ty, val, body, substs, depth), + KExprNode.Lit(lit) => store(KExprNode.Lit(lit)), + KExprNode.Proj(tidx, fidx, e1) => + store(KExprNode.Proj(tidx, fidx, legacy_inst_many(e1, substs, depth))), + } + } + + -- Cold-extracted Let arm (same pattern as `expr_lbr_let`). + fn legacy_inst_many_let(ty: KExpr, val: KExpr, body: KExpr, + substs: List‹KExpr›, depth: G) -> KExpr { + store(KExprNode.Let( + legacy_inst_many(ty, substs, depth), + legacy_inst_many(val, substs, depth), + legacy_inst_many(body, substs, depth + 1))) + } +⟧ + +/-! Independent Nat-indexed de Bruijn model. The theorem below proves that +trimming a sufficiently long prefix preserves substitution when the original +removal count is kept. It does not certify the entire Aiur compiler. -/ +private inductive Expr where + | var : Nat → Expr + | sort : Nat → Expr + | app : Expr → Expr → Expr + | lam : Expr → Expr → Expr + | all : Expr → Expr → Expr + | letE : Expr → Expr → Expr → Expr + | proj : Expr → Expr + | constE + | lit + deriving BEq, Repr, Inhabited + +private def lift : Expr → Nat → Nat → Expr + | .var i, shift, cutoff => .var (if i < cutoff then i else i + shift) + | .app f a, s, c => .app (lift f s c) (lift a s c) + | .lam t b, s, c => .lam (lift t s c) (lift b s (c + 1)) + | .all t b, s, c => .all (lift t s c) (lift b s (c + 1)) + | .letE t v b, s, c => .letE (lift t s c) (lift v s c) (lift b s (c + 1)) + | .proj e, s, c => .proj (lift e s c) + | e, _, _ => e + +private def subst : Expr → List Expr → Nat → Nat → Expr + | .var i, ss, n, d => + if i < d then .var i else if i < d + n then + lift (ss[i-d]?.getD (.sort 0)) d 0 else .var (i - n) + | .app f a, ss, n, d => .app (subst f ss n d) (subst a ss n d) + | .lam t b, ss, n, d => .lam (subst t ss n d) (subst b ss n (d + 1)) + | .all t b, ss, n, d => .all (subst t ss n d) (subst b ss n (d + 1)) + | .letE t v b, ss, n, d => .letE (subst t ss n d) (subst v ss n d) (subst b ss n (d + 1)) + | .proj e, ss, n, d => .proj (subst e ss n d) + | e, _, _, _ => e + +private def needed : Expr → Nat → Nat → Nat + | .var i, d, n => if i < d then 0 else if i < d + n then i - d + 1 else 0 + | .app f a, d, n => max (needed f d n) (needed a d n) + | .lam t b, d, n | .all t b, d, n => max (needed t d n) (needed b (d + 1) n) + | .letE t v b, d, n => max (max (needed t d n) (needed v d n)) (needed b (d + 1) n) + | .proj e, d, n => needed e d n + | _, _, _ => 0 + +private theorem needed_le_count (e : Expr) (d n : Nat) : needed e d n ≤ n := by + induction e generalizing d with + | var i => simp only [needed]; split <;> (try split) <;> omega + | sort _ | constE | lit => simp [needed] + | app f a ihf iha => exact Nat.max_le.mpr ⟨ihf d, iha d⟩ + | lam t b iht ihb | all t b iht ihb => exact Nat.max_le.mpr ⟨iht d, ihb (d + 1)⟩ + | letE t v b iht ihv ihb => exact Nat.max_le.mpr ⟨Nat.max_le.mpr ⟨iht d, ihv d⟩, ihb (d + 1)⟩ + | «proj» e ih => exact ih d + +private theorem projected_subst_eq (e : Expr) (ss : List Expr) (n d k : Nat) + (h : needed e d n ≤ k) : subst e (ss.take k) n d = subst e ss n d := by + induction e generalizing ss n d k with + | var i => + by_cases hlocal : i < d + · simp [subst, hlocal] + · by_cases inside : i < d + n + · have slot : i - d < k := by simp [needed, hlocal, inside] at h; omega + simp [subst, hlocal, inside, slot] + · simp [subst, hlocal, inside] + | sort _ | constE | lit => rfl + | app f a ihf iha => + simp only [needed, Nat.max_le] at h + simp only [subst, ihf ss n d k h.1, iha ss n d k h.2] + | lam t b iht ihb | all t b iht ihb => + simp only [needed, Nat.max_le] at h + simp only [subst, iht ss n d k h.1, ihb ss n (d + 1) k h.2] + | letE t v b iht ihv ihb => + simp only [needed, Nat.max_le] at h + simp only [subst, iht ss n d k h.1.1, ihv ss n d k h.1.2, ihb ss n (d + 1) k h.2] + | «proj» e ih => simp only [needed] at h; simp only [subst, ih ss n d k h] + +private def fixtures := ⟦ + fn projection_read_expr(offset: G) -> (KExpr, G) { + let [tag] = io_read(0, offset, 1); + match tag { + 0 => let [i] = io_read(0, offset + 1, 1); + (store(KExprNode.BVar(i)), offset + 2), + 1 => let [i] = io_read(0, offset + 1, 1); + (store(KExprNode.Srt(store(KLevelNode.Param(i)))), offset + 2), + 2 => let (f, next) = projection_read_expr(offset + 1); + let (a, after) = projection_read_expr(next); + (store(KExprNode.App(f, a)), after), + 3 => let (t, next) = projection_read_expr(offset + 1); + let (b, after) = projection_read_expr(next); + (store(KExprNode.Lam(t, b)), after), + 4 => let (t, next) = projection_read_expr(offset + 1); + let (b, after) = projection_read_expr(next); + (store(KExprNode.Forall(t, b)), after), + 5 => let (t, next) = projection_read_expr(offset + 1); + let (v, next) = projection_read_expr(next); + let (b, after) = projection_read_expr(next); + (store(KExprNode.Let(t, v, b)), after), + 6 => let (e, after) = projection_read_expr(offset + 1); + let addr = store([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, + 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, + 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, + 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + (store(KExprNode.Proj(addr, 2, e)), after), + 7 => let addr = store([0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, + 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, + 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, + 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]); + (store(KExprNode.Const(addr, store(ListNode.Nil))), offset + 1), + 8 => (store(KExprNode.Lit(KLiteral.Nat(store(ListNode.Nil)))), offset + 1), + } + } + + fn projection_read_substs(n: G, offset: G) -> (List‹KExpr›, G) { + match n { + 0 => (store(ListNode.Nil), offset), + _ => let (e, next) = projection_read_expr(offset); + let (rest, after) = projection_read_substs(n - 1, next); + (store(ListNode.Cons(e, rest)), after), + } + } + + fn projection_batch_loop(mode: G, ncases: G, offset: G) { + match ncases { + 0 => (), + _ => let [depth, n, k] = io_read(0, offset, 3); + let (e, next) = projection_read_expr(offset + 3); + let (substs, next) = projection_read_substs(n, next); + let (expected, after) = projection_read_expr(next); + match mode { + 0 => assert_eq!(expr_inst_many(e, substs, depth), expected, "projected substitution"); (), + 1 => assert_eq!(legacy_inst_many(e, substs, depth), expected, "reference substitution"); (), + 2 => + assert_eq!(expr_inst_prefix_len(e, depth, depth + n), k, "referenced prefix length"); + assert_eq!(expr_inst_many(e, substs, depth), expected, "projected substitution"); + assert_eq!(legacy_inst_many(e, substs, depth), expected, "reference substitution"); (), + }; + projection_batch_loop(mode, ncases - 1, after), + } + } + + pub fn projection_batch(mode: G, ncases: G) -> G { + projection_batch_loop(mode, ncases, 0); + 1 + } +⟧ + +private def source : Except Global Source.Toplevel := do + let vm ← IxVM.ixVMFull + let vm ← vm.merge reference + let vm ← vm.merge fixtures + pure (vm.prune [`projection_batch]) + +private def encode : Expr → List Nat + | .var i => [0, i] + | .sort i => [1, i] + | .app f a => 2 :: (encode f ++ encode a) + | .lam t b => 3 :: (encode t ++ encode b) + | .all t b => 4 :: (encode t ++ encode b) + | .letE t v b => 5 :: (encode t ++ encode v ++ encode b) + | .proj e => 6 :: encode e + | .constE => [7] + | .lit => [8] + +private structure Case where + e : Expr + ss : List Expr + depth : Nat := 0 + +private def encodeCase (c : Case) : List Nat := + [c.depth, c.ss.length, needed c.e c.depth c.ss.length] ++ encode c.e ++ + c.ss.flatMap encode ++ encode (subst c.e c.ss c.ss.length c.depth) + +private def testCase (cases : List Case) (mode : Nat) (label : String) : AiurTestCase := + let data := (cases.flatMap encodeCase).toArray.map G.ofNat + let io : IOBuffer := { data := ({} : Std.HashMap _ _).insert 0 data, map := {} } + { functionName := `projection_batch, label, input := #[G.ofNat mode, G.ofNat cases.length], + expectedOutput := #[1], inputIOBuffer := io, expectedIOBuffer := io, + withProof := false } + +private def boundaryCases : List Case := Id.run do + let mut cases := [] + for d in [0, 1, 3] do + for n in [0, 1, 2, 5] do + let ss := (List.range n).map fun i => + if i % 2 == 0 then Expr.app (.var i) (.sort (17 + i)) + else .lam (.sort i) (.app (.var 0) (.var (i + 1))) + for i in [0, d, d + n, d + n + 7] do + let e := Expr.app (.var i) (.app (.var d) (.var (d + n + 7))) + for body in [e, .lam (.var d) e, .all e (.lam (.sort 0) e), + .letE (.var d) e (.app (.var 0) e), .proj e] do + cases := cases ++ [{ e := body, ss, depth := d }] + for e in [Expr.sort 0, .constE, .lit] do + cases := cases ++ [{ e, ss, depth := d }] + return cases + +private def sharingCases (variants nodes : Nat) : List Case := + let e := (List.range nodes).foldl (fun e i => Expr.app (.sort i) e) (.var 0) + (List.range variants).map fun i => + { e, ss := [.app (.var 0) (.sort 777), .sort (1000+i), .sort (2000+i), .sort (3000+i)] } + +private def familyRows (env : AiurTestEnv) (qc : Array QueryCount) (legacy : Bool) : Nat := + let names := if legacy then + [`legacy_inst_many, `legacy_inst_many_walk, `legacy_inst_many_bvar, `legacy_inst_many_let] + else [`expr_inst_many, `expr_inst_many_projected, `expr_inst_many_walk, + `expr_inst_many_bvar, `expr_inst_many_let, `expr_inst_prefix_len, + `expr_inst_prefix_walk, `expr_inst_prefix_let] + names.foldl (fun total name => match env.compiled.getFuncIdx name with + | some idx => total + (qc[idx]?.map (·.uniqueRows)).getD 0 + | none => total) 0 + +private def sharingTests (env : AiurTestEnv) : IO TestSeq := do + let mut seq := .done + for (variants, nodes) in [(8, 16), (32, 64)] do + let cases := sharingCases variants nodes + let some idx := env.compiled.getFuncIdx `projection_batch | return test "entry missing" false + let current := testCase cases 0 "projected sharing" + let previous := testCase cases 1 "reference sharing" + match env.compiled.bytecode.execute idx current.input current.inputIOBuffer, + env.compiled.bytecode.execute idx previous.input previous.inputIOBuffer with + | .ok (_, _, now), .ok (_, _, old) => + let rows := familyRows env now false + let oldRows := familyRows env old true + let fft := (computeStats env.compiled now env.shapes).totalFftCost + let oldFft := (computeStats env.compiled old env.shapes).totalFftCost + IO.println s!"[subst-projection] variants={variants} nodes={nodes} family_rows={rows}/{oldRows} FFT={fft}/{oldFft} (new/old)" + seq := seq ++ test s!"{variants}/{nodes}: fewer substitution and summary rows" (rows < oldRows) + ++ test s!"{variants}/{nodes}: total fixture FFT improves" (fft < oldFft) + | _, _ => seq := seq ++ test s!"sharing fixture {variants}/{nodes} executes" false + return seq + +def run : IO UInt32 := do + let .ok env := AiurTestEnv.build source + | IO.eprintln "substitution projection fixture build failed"; return 1 + let cases := boundaryCases + let mut status := 0 + for i in [: (cases.length + 15) / 16] do + let batch := (cases.drop (i * 16)).take 16 + let r ← lspecEachIO [testCase batch 2 s!"substitution boundary batch {i}"] + fun tc => pure (env.runTestCase tc) + if r != 0 then status := r + let shares ← sharingTests env + let r ← lspecIO (.ofList [("ixvm-subst-projection", [shares])]) [] + if r != 0 then status := r + let proofCases : List Case := [ + { e := .app (.var 0) (.var 9), ss := [.var 1, .sort 7, .sort 8] }, + { e := .lam (.var 1) (.app (.var 0) (.app (.var 2) (.var 12))), + ss := [.var 1, .sort 7, .sort 8], depth := 1 }, + { e := .letE (.var 0) (.var 0) (.proj (.app (.var 1) (.var 8))), + ss := [.all (.sort 1) (.var 2), .sort 2] }] + for (c, i) in proofCases.zipIdx do + let tc := { testCase [c] 2 s!"substitution projection proof {i}" with withProof := true } + let r ← lspecEachIO [tc] fun tc => pure (env.runTestCase tc) + if r != 0 then status := r + return status + +end Tests.Ix.IxVM.SubstProjection +end diff --git a/Tests/Main.lean b/Tests/Main.lean index c75ca7c84..50e718fcd 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -4,6 +4,11 @@ import Tests.Ix.IxonCorpus import Tests.Ix.IxonSyntax import Tests.Ix.IxVM import Tests.Ix.IxVM.Exploits +import Tests.Ix.IxVM.ByteHints +import Tests.Ix.IxVM.LimbMul +import Tests.Ix.IxVM.FusedMul +import Tests.Ix.IxVM.CarryAdd +import Tests.Ix.IxVM.SubstProjection import Tests.Ix.Claim import Tests.Ix.Merkle import Tests.Ix.AssumptionTree @@ -162,6 +167,11 @@ execute at module initialization for unrelated invocations. All are seconds-scale (measured 2026-08-05: aiur-prove ~11s, the rest 2-4s each). -/ def primaryRunners : List (String × IO UInt32) := [ + ("ixvm-byte-hints", Tests.Ix.IxVM.ByteHints.run), + ("ixvm-limb-mul", Tests.Ix.IxVM.LimbMul.run), + ("ixvm-fused-mul", Tests.Ix.IxVM.FusedMul.run), + ("ixvm-carry-add", Tests.Ix.IxVM.CarryAdd.run), + ("ixvm-subst-projection", Tests.Ix.IxVM.SubstProjection.run), ("aiur-prove", do IO.println "aiur-prove" match AiurTestEnv.build (pure toplevel) with @@ -276,8 +286,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 6_946_001_069, got {actual}" - (actual = 6_946_001_069)) + s!"Shard pipeline FFT matches: expected 7_008_644_066, got {actual}" + (actual = 7_008_644_066)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), @@ -299,6 +309,9 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ ] def main (args : List String) : IO UInt32 := do + if let some arg := args.find? (·.startsWith "ixvm-byte-hints-probe=") then + return ← Tests.Ix.IxVM.ByteHints.runOutOfRangeProbe + (arg.drop "ixvm-byte-hints-probe=".length).toString -- Special case: namespace-filtered kernel ixon roundtrip diagnostic. -- `kernel-roundtrip-ns=Nat.le` runs the same pipeline as the -- `kernel-ixon-roundtrip` suite (compile → ingress → egress → diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index cfa91823c..466b96e4e 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -1,6 +1,14 @@ use multi_stark::p3_field::{Field, PrimeCharacteristicRing, PrimeField64}; use rustc_hash::FxHashMap; use std::collections::hash_map::Entry; +use std::{ + sync::Arc, + time::{Duration, Instant}, +}; + +pub mod budget; +use budget::{BudgetExceeded, Charge, ExecutionBudget}; +mod stats; use crate::{ FxIndexMap, G, @@ -10,7 +18,7 @@ use crate::{ bytes1::{Bytes1, Bytes1Op, Bytes1Queries}, bytes2::{Bytes2, Bytes2Op, Bytes2Queries}, }, - querymap::QueryMap, + querymap::{QueryMap, hash_g_slice}, }; fn u32_value(map: &[G], bytes: &[usize]) -> u64 { @@ -33,23 +41,148 @@ pub struct QueryRecord { pub memory_queries: FxIndexMap, pub bytes1_queries: Bytes1Queries, pub bytes2_queries: Bytes2Queries, + budget: Option>, + _base_charge: Option, + checkpoints: u64, + logged: Instant, + current_function: usize, } impl QueryRecord { pub fn new(toplevel: &Toplevel) -> Self { + Self::create(toplevel, None, None) + } + + pub fn with_budget( + toplevel: &Toplevel, + io: &IOBuffer, + budget: Option>, + ) -> Result { + // Byte gadget tables are fixed-size (< 8 MiB combined). IO storage is + // already built by the caller; account it before starting execution. + let charge = budget + .as_ref() + .map(|b| { + let base = io + .data + .values() + .fold(8u64 << 20, |n, v| { + n.saturating_add((v.capacity() as u64).saturating_mul(8)) + }) + .saturating_add(io.map.iter().fold(0u64, |n, ((_, k), _)| { + n.saturating_add( + (k.capacity() as u64).saturating_mul(8).saturating_add(128), + ) + })); + b.charge(base) + }) + .transpose()?; + Ok(Self::create(toplevel, budget, charge)) + } + + fn create( + toplevel: &Toplevel, + budget: Option>, + charge: Option, + ) -> Self { let function_queries = toplevel .functions .iter() - .map(|f| QueryMap::new(f.layout.input_size)) + .map(|f| QueryMap::with_budget(f.layout.input_size, budget.clone())) .collect(); let memory_queries = toplevel .memory_sizes .iter() - .map(|width| (*width, QueryMap::new(*width))) + .map(|width| { + (*width, QueryMap::with_memory_budget(*width, budget.clone())) + }) .collect(); let bytes1_queries = Bytes1Queries::new(); let bytes2_queries = Bytes2Queries::new(); - Self { function_queries, memory_queries, bytes1_queries, bytes2_queries } + Self { + function_queries, + memory_queries, + bytes1_queries, + bytes2_queries, + budget, + _base_charge: charge, + checkpoints: 0, + logged: Instant::now(), + current_function: 0, + } + } + + /// Generated functions and interpreter operations both visit this hook. + /// Diagnostics stay bounded by the fixed function/memory map count, never + /// by the number of expressions. Allocation limits are checked at inserts. + #[inline] + pub fn checkpoint(&mut self, function: usize) { + if self.budget.is_none() { + return; + } + self.current_function = function; + self.checkpoints = self.checkpoints.wrapping_add(1); + if self.checkpoints.is_multiple_of(1 << 16) + && self.logged.elapsed() >= Duration::from_secs(5) + { + self.log_budget("running"); + self.logged = Instant::now(); + } + } + + pub fn execution_error(&self, error: ExecError) -> ExecError { + let error = + if let Some(failure) = self.budget.as_ref().and_then(|b| b.failure()) { + self.log_budget("resource-limit"); + ExecError::ResourceLimit(failure) + } else { + error + }; + self.log_multiplicity_stats( + if matches!(error, ExecError::ResourceLimit(_)) { + "resource-limit" + } else { + "rejected" + }, + ); + error + } + + fn log_budget(&self, status: &str) { + let Some(b) = &self.budget else { + return; + }; + let mut rows: Vec<_> = self + .function_queries + .iter() + .enumerate() + .filter(|(_, m)| !m.is_empty()) + .map(|(id, m)| (m.accounted_bytes(), format!("fn{id}"), m.len())) + .chain( + self + .memory_queries + .iter() + .filter(|(_, m)| !m.is_empty()) + .map(|(w, m)| (m.accounted_bytes(), format!("mem{w}"), m.len())), + ) + .collect(); + rows.sort_unstable_by(|a, b| b.0.cmp(&a.0).then_with(|| a.1.cmp(&b.1))); + let top: Vec<_> = rows + .iter() + .take(8) + .map(|(bytes, name, entries)| { + format!("{name}:{entries}rows/{}MiB", bytes >> 20) + }) + .collect(); + eprintln!( + "[ixvm_record] {} {status}: accounted={}MiB peak={}MiB limit={}MiB current=fn{} top=[{}]", + b.label, + b.used() >> 20, + b.peak() >> 20, + b.limit() >> 20, + self.current_function, + top.join(", ") + ); } } @@ -112,6 +245,7 @@ impl IOBuffer { /// genuine bytecode bugs. #[derive(Debug, Clone, PartialEq, Eq)] pub enum ExecError { + ResourceLimit(BudgetExceeded), NotEntryFunction(FunIdx), InvalidMemorySize(usize), UnboundPointer { @@ -152,6 +286,7 @@ pub enum ExecError { impl std::fmt::Display for ExecError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { + Self::ResourceLimit(error) => std::fmt::Display::fmt(error, f), Self::NotEntryFunction(idx) => { write!(f, "cannot execute non-entry function {idx}") }, @@ -192,58 +327,126 @@ impl std::fmt::Display for ExecError { impl std::error::Error for ExecError {} +impl From for ExecError { + fn from(error: BudgetExceeded) -> Self { + Self::ResourceLimit(error) + } +} + /// Gated by `IX_AIUR_QUERY_STATS=1`: dump per-function query-map sizes /// during/after execution so RAM blowups can be attributed to specific /// Aiur functions (indices resolve to names via the Lean -/// `CompiledToplevel`). Heaviest maps first, by retained G elements. +/// `CompiledToplevel`). Heaviest maps first, by encoded payload bytes. static QUERY_STATS: std::sync::LazyLock = std::sync::LazyLock::new(|| { std::env::var_os("IX_AIUR_QUERY_STATS").is_some() }); fn dump_query_stats(record: &QueryRecord, tag: &str) { - let mut rows: Vec<(usize, usize, usize)> = record + let mut rows: Vec<(usize, usize, usize, usize)> = record .function_queries .iter() .enumerate() - .map(|(i, m)| (i, m.len(), m.retained_elems())) - .filter(|(_, n, _)| *n > 0) + .map(|(i, m)| (i, m.len(), m.retained_elems(), m.retained_bytes())) + .filter(|(_, n, _, _)| *n > 0) .collect(); - rows.sort_by_key(|row| std::cmp::Reverse(row.2)); + rows.sort_by_key(|row| std::cmp::Reverse(row.3)); let total_entries: usize = rows.iter().map(|r| r.1).sum(); let total_elems: usize = rows.iter().map(|r| r.2).sum(); + let total_bytes: usize = rows.iter().map(|r| r.3).sum(); eprintln!( "[aiur-stats {tag}] function_queries: {total_entries} entries, \ - {total_elems} G-elems; top maps:" + {total_elems} logical G-elems, {total_bytes} payload bytes; top maps:" ); - for (i, n, e) in rows.iter().take(30) { - eprintln!(" fn{i:<4} entries={n:<12} g_elems={e}"); + for (i, n, e, b) in rows.iter().take(30) { + eprintln!(" fn{i:<4} entries={n:<12} g_elems={e} payload_bytes={b}"); } let mem: Vec = record .memory_queries .iter() - .map(|(w, m)| format!("w{w}={}", m.len())) + .map(|(w, m)| format!("w{w}={}rows/{}bytes", m.len(), m.retained_bytes())) .collect(); eprintln!("[aiur-stats {tag}] memory entries: {}", mem.join(" ")); } impl Toplevel { - pub fn execute( + /// Full-width reference storage for differential witness/proof tests. + /// This deliberately shares the interpreter, but never byte-encodes rows. + #[cfg(test)] + pub(crate) fn execute_uncompressed( + &self, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, + ) -> Result<(QueryRecord, Vec), ExecError> { + self.execute_test_storage(fun_idx, args, io_buffer, false) + } + + /// Force both column and counter encodings in differential tests, without + /// mutating a process-global environment variable or depending on opt-in. + #[cfg(test)] + pub(crate) fn execute_test_storage( &self, fun_idx: FunIdx, args: Vec, io_buffer: &mut IOBuffer, + compact: bool, ) -> Result<(QueryRecord, Vec), ExecError> { if !self.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } let mut record = QueryRecord::new(self); + for (map, function) in + record.function_queries.iter_mut().zip(&self.functions) + { + *map = QueryMap::with_encodings( + function.layout.input_size, + None, + compact, + compact, + ); + } + for (&size, map) in &mut record.memory_queries { + *map = QueryMap::with_encodings(size, None, compact, compact); + } + let output = self.functions[fun_idx].execute( + fun_idx, + args, + self, + &mut record, + io_buffer, + )?; + Ok((record, output)) + } + + pub fn execute( + &self, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, + ) -> Result<(QueryRecord, Vec), ExecError> { + self.execute_with_budget(fun_idx, args, io_buffer, None) + } + + pub fn execute_with_budget( + &self, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, + budget: Option>, + ) -> Result<(QueryRecord, Vec), ExecError> { + if !self.functions[fun_idx].entry { + return Err(ExecError::NotEntryFunction(fun_idx)); + } + let mut record = QueryRecord::with_budget(self, io_buffer, budget)?; let function = &self.functions[fun_idx]; - let output = - function.execute(fun_idx, args, self, &mut record, io_buffer)?; + let output = function + .execute(fun_idx, args, self, &mut record, io_buffer) + .map_err(|e| record.execution_error(e))?; if *QUERY_STATS { dump_query_stats(&record, "final"); } + record.log_multiplicity_stats("returned"); Ok((record, output)) } } @@ -258,6 +461,7 @@ struct CallerState { map: Vec, unconstrained: bool, continuation_depth: usize, + query_hash: u64, } struct ContinuationState<'a> { @@ -285,8 +489,10 @@ impl Function { } push_block_exec_entries!(&self.body); let mut unconstrained = false; + let mut query_hash = hash_g_slice(&map[..self.layout.input_size]); let mut stats_ops: u64 = 0; while let Some(exec_entry) = exec_entries_stack.pop() { + record.checkpoint(fun_idx); if *QUERY_STATS { stats_ops += 1; if stats_ops.is_multiple_of(1 << 31) { @@ -327,10 +533,11 @@ impl Function { }, ExecEntry::Op(Op::Call(callee_idx, args, _, op_unconstrained)) => { let args: Vec = args.iter().map(|i| map[*i]).collect(); + let callee_hash = hash_g_slice(&args); let callee_unconstrained = unconstrained || *op_unconstrained; let mut cached_output = None; - if let Some(i) = - record.function_queries[*callee_idx].get_index_of(&args) + if let Some(i) = record.function_queries[*callee_idx] + .get_index_of_hashed(&args, callee_hash) { // A zero-multiplicity entry was computed only as an // unconstrained hint. Promoting just this row would omit all @@ -340,7 +547,7 @@ impl Function { let mult = record.function_queries[*callee_idx].mult_at(i); if callee_unconstrained || !mult.is_zero() { if !callee_unconstrained { - record.function_queries[*callee_idx].bump_multiplicity(i); + record.function_queries[*callee_idx].bump_multiplicity(i)?; } cached_output = Some( record.function_queries[*callee_idx].output_at(i).to_vec(), @@ -356,8 +563,10 @@ impl Function { map: saved_map, unconstrained, continuation_depth: continuation_stack.len(), + query_hash, }); fun_idx = *callee_idx; + query_hash = callee_hash; unconstrained = callee_unconstrained; push_block_exec_entries!(&toplevel.functions[fun_idx].body); } @@ -365,22 +574,24 @@ impl Function { ExecEntry::Op(Op::Store(values)) => { let values = values.iter().map(|v| map[*v]).collect::>(); let size = values.len(); + let hash = hash_g_slice(&values); let memory_queries = record .memory_queries .get_mut(&size) .ok_or(ExecError::InvalidMemorySize(size))?; - if let Some(i) = memory_queries.get_index_of(&values) { + if let Some(i) = memory_queries.get_index_of_hashed(&values, hash) { if !unconstrained { - memory_queries.bump_multiplicity(i); + memory_queries.bump_multiplicity(i)?; } - map.extend_from_slice(memory_queries.output_at(i)); + map.extend(memory_queries.output_at(i).iter()); } else { let ptr = G::from_usize(memory_queries.len()); - memory_queries.insert( + memory_queries.insert_hashed( &values, + hash, &[ptr], G::from_bool(!unconstrained), - ); + )?; map.push(ptr); } }, @@ -401,11 +612,11 @@ impl Function { }); } if !unconstrained { - memory_queries.bump_multiplicity(ptr_usize); + memory_queries.bump_multiplicity(ptr_usize)?; } let (args, _) = memory_queries.get_index(ptr_usize).expect("bounds checked above"); - map.extend_from_slice(args); + map.extend(args.iter()); }, ExecEntry::Op(Op::AssertEq(xs, ys, msg)) => { if xs.len() != ys.len() { @@ -464,40 +675,39 @@ impl Function { &Bytes1Op::BitDecomposition, &mut map, record, - ); + )?; } }, ExecEntry::Op(Op::U8ShiftLeft(byte)) => { if unconstrained { map.push(Bytes1::shift_left(&map[*byte])); } else { - bytes1_execute(*byte, &Bytes1Op::ShiftLeft, &mut map, record); + bytes1_execute(*byte, &Bytes1Op::ShiftLeft, &mut map, record)?; } }, ExecEntry::Op(Op::U8ShiftRight(byte)) => { if unconstrained { map.push(Bytes1::shift_right(&map[*byte])); } else { - bytes1_execute(*byte, &Bytes1Op::ShiftRight, &mut map, record); + bytes1_execute(*byte, &Bytes1Op::ShiftRight, &mut map, record)?; } }, ExecEntry::Op(Op::U8Xor(i, j)) => { if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; map.push(Bytes2::xor(&map[*i], &map[*j])); } else { - bytes2_execute(*i, *j, &Bytes2Op::Xor, &mut map, record); + bytes2_execute(*i, *j, &Bytes2Op::Xor, &mut map, record)?; } }, ExecEntry::Op(Op::U8Add(i, j)) => { - // The add gadget yields only the low byte; the carry is derived - // and pushed separately so the op still produces `(low, carry)`. - let (_r, o) = Bytes2::add(&map[*i], &map[*j]); - if unconstrained { - map.push(Bytes2::add(&map[*i], &map[*j]).0); + let (a, b) = if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; + Bytes2::add(&map[*i], &map[*j]) } else { - bytes2_execute(*i, *j, &Bytes2Op::Add, &mut map, record); - } - map.push(o); + bytes2_add_value(map[*i], map[*j], record)? + }; + map.extend([a, b]); }, ExecEntry::Op(Op::UnconstrainedU32Add(a, b)) => { let (bytes, carry) = @@ -519,42 +729,44 @@ impl Function { }, ExecEntry::Op(Op::U8Mul(i, j)) => { if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; let (lo, hi) = Bytes2::mul(&map[*i], &map[*j]); map.extend([lo, hi]); } else { - bytes2_execute(*i, *j, &Bytes2Op::Mul, &mut map, record); + bytes2_execute(*i, *j, &Bytes2Op::Mul, &mut map, record)?; } }, ExecEntry::Op(Op::U8Sub(i, j)) => { - // The sub gadget yields only the low byte; the borrow is derived - // and pushed separately so the op still produces `(low, borrow)`. - let (_r, u) = Bytes2::sub(&map[*i], &map[*j]); - if unconstrained { - map.push(Bytes2::sub(&map[*i], &map[*j]).0); + let (a, b) = if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; + Bytes2::sub(&map[*i], &map[*j]) } else { - bytes2_execute(*i, *j, &Bytes2Op::Sub, &mut map, record); - } - map.push(u); + bytes2_sub_value(map[*i], map[*j], record)? + }; + map.extend([a, b]); }, ExecEntry::Op(Op::U8And(i, j)) => { if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; map.push(Bytes2::and(&map[*i], &map[*j])); } else { - bytes2_execute(*i, *j, &Bytes2Op::And, &mut map, record); + bytes2_execute(*i, *j, &Bytes2Op::And, &mut map, record)?; } }, ExecEntry::Op(Op::U8Or(i, j)) => { if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; map.push(Bytes2::or(&map[*i], &map[*j])); } else { - bytes2_execute(*i, *j, &Bytes2Op::Or, &mut map, record); + bytes2_execute(*i, *j, &Bytes2Op::Or, &mut map, record)?; } }, ExecEntry::Op(Op::U8LessThan(i, j)) => { if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; map.push(Bytes2::less_than(&map[*i], &map[*j])); } else { - bytes2_execute(*i, *j, &Bytes2Op::LessThan, &mut map, record); + bytes2_execute(*i, *j, &Bytes2Op::LessThan, &mut map, record)?; } }, ExecEntry::Op(Op::U32LessThan(x_idx, y_idx)) => { @@ -582,22 +794,26 @@ impl Function { ] { record .bytes2_queries - .bump_range_check(&G::from_u8(i), &G::from_u8(j)); + .bump_range_check(&G::from_u8(i), &G::from_u8(j))?; } } }, ExecEntry::Op(Op::U8XorSplit7(i, j)) => { - let (a, b) = Bytes2::xor_split7(&map[*i], &map[*j]); - if !unconstrained { - record.bytes2_queries.bump_xor_split7(&map[*i], &map[*j]); - } + let (a, b) = if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; + Bytes2::xor_split7(&map[*i], &map[*j]) + } else { + bytes2_xor_split7_value(map[*i], map[*j], record)? + }; map.extend([a, b]); }, ExecEntry::Op(Op::U8XorSplit4(i, j)) => { - let (a, b) = Bytes2::xor_split4(&map[*i], &map[*j]); - if !unconstrained { - record.bytes2_queries.bump_xor_split4(&map[*i], &map[*j]); - } + let (a, b) = if unconstrained { + Bytes2::validate_inputs(&map[*i], &map[*j])?; + Bytes2::xor_split4(&map[*i], &map[*j]) + } else { + bytes2_xor_split4_value(map[*i], map[*j], record)? + }; map.extend([a, b]); }, ExecEntry::Op(Op::U8RangeCheck(i, j)) => { @@ -605,14 +821,7 @@ impl Function { // Records a range-check query so the byte-chip lookup is satisfied. if !unconstrained { let (vi, vj) = (map[*i], map[*j]); - let (bi, bj) = (vi.as_canonical_u64(), vj.as_canonical_u64()); - if bi >= 256 { - return Err(ExecError::U8RangeCheckFailed(bi)); - } - if bj >= 256 { - return Err(ExecError::U8RangeCheckFailed(bj)); - } - record.bytes2_queries.bump_range_check(&vi, &vj); + record.bytes2_queries.bump_range_check(&vi, &vj)?; } }, ExecEntry::Op(Op::UnconstrainedBigUintDivMod(a_idx, b_idx)) => { @@ -718,20 +927,23 @@ impl Function { ExecEntry::Ctrl(Ctrl::Return(_, output)) => { let input_size = toplevel.functions[fun_idx].layout.input_size; let output = output.iter().map(|i| map[*i]).collect::>(); - record.function_queries[fun_idx].finish( + record.function_queries[fun_idx].finish_hashed( &map[..input_size], + query_hash, &output, !unconstrained, - ); + )?; if let Some(CallerState { fun_idx: caller_idx, map: caller_map, unconstrained: caller_unconstrained, continuation_depth, + query_hash: caller_hash, }) = callers_states_stack.pop() { continuation_stack.truncate(continuation_depth); fun_idx = caller_idx; + query_hash = caller_hash; map = caller_map; map.extend(output); unconstrained = caller_unconstrained; @@ -755,8 +967,9 @@ pub fn bytes1_execute( op: &Bytes1Op, map: &mut Vec, record: &mut QueryRecord, -) { - map.extend(Bytes1.execute(op, &[map[byte]], record)); +) -> Result<(), ExecError> { + map.extend(Bytes1.execute(op, &[map[byte]], record)?); + Ok(()) } pub fn bytes2_execute( @@ -765,8 +978,9 @@ pub fn bytes2_execute( op: &Bytes2Op, map: &mut Vec, record: &mut QueryRecord, -) { - map.extend(Bytes2.execute(op, &[map[i], map[j]], record)); +) -> Result<(), ExecError> { + map.extend(Bytes2.execute(op, &[map[i], map[j]], record)?); + Ok(()) } // ============================================================================ @@ -785,10 +999,13 @@ pub fn bytes2_execute( // ============================================================================ #[inline] -pub fn bytes1_bit_decompose_value(byte: G, record: &mut QueryRecord) -> [G; 8] { - record.bytes1_queries.bump_bit_decomposition(&byte); +pub fn bytes1_bit_decompose_value( + byte: G, + record: &mut QueryRecord, +) -> Result<[G; 8], ExecError> { + record.bytes1_queries.bump_bit_decomposition(&byte)?; let byte_u64 = byte.as_canonical_u64(); - [ + Ok([ G::from_bool(byte_u64 & 1 == 1), G::from_bool(byte_u64 >> 1 & 1 == 1), G::from_bool(byte_u64 >> 2 & 1 == 1), @@ -797,70 +1014,104 @@ pub fn bytes1_bit_decompose_value(byte: G, record: &mut QueryRecord) -> [G; 8] { G::from_bool(byte_u64 >> 5 & 1 == 1), G::from_bool(byte_u64 >> 6 & 1 == 1), G::from_bool(byte_u64 >> 7 & 1 == 1), - ] + ]) } /// IxVM kernel doesn't emit `Op::U8ShiftLeft` today; kept for codegen /// of other toplevels that might. #[inline] #[allow(dead_code)] -pub fn bytes1_shift_left_value(byte: G, record: &mut QueryRecord) -> G { - record.bytes1_queries.bump_shift_left(&byte); - Bytes1::shift_left(&byte) +pub fn bytes1_shift_left_value( + byte: G, + record: &mut QueryRecord, +) -> Result { + record.bytes1_queries.bump_shift_left(&byte)?; + Ok(Bytes1::shift_left(&byte)) } /// IxVM kernel doesn't emit `Op::U8ShiftRight` today; kept for /// codegen of other toplevels. #[inline] #[allow(dead_code)] -pub fn bytes1_shift_right_value(byte: G, record: &mut QueryRecord) -> G { - record.bytes1_queries.bump_shift_right(&byte); - Bytes1::shift_right(&byte) +pub fn bytes1_shift_right_value( + byte: G, + record: &mut QueryRecord, +) -> Result { + record.bytes1_queries.bump_shift_right(&byte)?; + Ok(Bytes1::shift_right(&byte)) } #[inline] -pub fn bytes2_xor_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_xor(&a, &b); - Bytes2::xor(&a, &b) +pub fn bytes2_xor_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result { + record.bytes2_queries.bump_xor(&a, &b)?; + Ok(Bytes2::xor(&a, &b)) } #[inline] -pub fn bytes2_and_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_and(&a, &b); - Bytes2::and(&a, &b) +pub fn bytes2_and_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result { + record.bytes2_queries.bump_and(&a, &b)?; + Ok(Bytes2::and(&a, &b)) } #[inline] -pub fn bytes2_or_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_or(&a, &b); - Bytes2::or(&a, &b) +pub fn bytes2_or_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result { + record.bytes2_queries.bump_or(&a, &b)?; + Ok(Bytes2::or(&a, &b)) } #[inline] -pub fn bytes2_less_than_value(a: G, b: G, record: &mut QueryRecord) -> G { - record.bytes2_queries.bump_less_than(&a, &b); - Bytes2::less_than(&a, &b) +pub fn bytes2_less_than_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result { + record.bytes2_queries.bump_less_than(&a, &b)?; + Ok(Bytes2::less_than(&a, &b)) } /// IxVM kernel doesn't emit `Op::U8Mul` today; kept for codegen of /// other toplevels. #[inline] #[allow(dead_code)] -pub fn bytes2_mul_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_mul(&a, &b); - Bytes2::mul(&a, &b) +pub fn bytes2_mul_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + record.bytes2_queries.bump_mul(&a, &b)?; + Ok(Bytes2::mul(&a, &b)) } #[inline] -pub fn bytes2_xor_split7_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_xor_split7(&a, &b); - Bytes2::xor_split7(&a, &b) +pub fn bytes2_xor_split7_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + record.bytes2_queries.bump_xor_split7(&a, &b)?; + Ok(Bytes2::xor_split7(&a, &b)) } #[inline] -pub fn bytes2_xor_split4_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_xor_split4(&a, &b); - Bytes2::xor_split4(&a, &b) +pub fn bytes2_xor_split4_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + record.bytes2_queries.bump_xor_split4(&a, &b)?; + Ok(Bytes2::xor_split4(&a, &b)) } /// Bumps `bytes2_queries.add` and returns the full `(low, carry)` @@ -868,15 +1119,23 @@ pub fn bytes2_xor_split4_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { /// chip; carry is derived natively. The codegen path uses this /// helper so the add gadget runs exactly once. #[inline] -pub fn bytes2_add_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_add(&a, &b); - Bytes2::add(&a, &b) +pub fn bytes2_add_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + record.bytes2_queries.bump_add(&a, &b)?; + Ok(Bytes2::add(&a, &b)) } #[inline] -pub fn bytes2_sub_value(a: G, b: G, record: &mut QueryRecord) -> (G, G) { - record.bytes2_queries.bump_sub(&a, &b); - Bytes2::sub(&a, &b) +pub fn bytes2_sub_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + record.bytes2_queries.bump_sub(&a, &b)?; + Ok(Bytes2::sub(&a, &b)) } /// Re-exports for the codegen'd kernel (`ix::aiur_ixvm`). The generated @@ -962,7 +1221,8 @@ fn find_klimbs_u64( let mut tail_ptr = queries .get(&nil_key) .ok_or_else(|| "List Nil node not recorded".to_string())? - .output[0]; + .output + .at(0); for limb in limbs.iter().rev() { let mut key: Vec = Vec::with_capacity(10); key.push(G::ZERO); // Cons tag (first variant of ListNode‹U64›) @@ -975,7 +1235,8 @@ fn find_klimbs_u64( .ok_or_else(|| { format!("List Cons node for limb {limb} not recorded") })? - .output[0]; + .output + .at(0); } Ok(tail_ptr) } @@ -1000,7 +1261,7 @@ fn read_klimbs_u64( let (key, _) = queries.get_index(ptr_idx).ok_or_else(|| { format!("unbound ptr {ptr_u64} in memory[10] (walking List)") })?; - let tag = key[0].as_canonical_u64(); + let tag = key.at(0).as_canonical_u64(); // `enum ListNode { Cons, Nil }` in Ix/IxVM/Core.lean — Cons is the // first variant (tag 0), Nil the second (tag 1). if tag == 1 { @@ -1012,15 +1273,15 @@ fn read_klimbs_u64( )); } let mut limb_bytes = [0u8; 8]; - for k in 0..8 { - let b = key[1 + k].as_canonical_u64(); + for (k, byte) in limb_bytes.iter_mut().enumerate() { + let b = key.at(1 + k).as_canonical_u64(); if b >= 256 { return Err(format!("limb byte {b} out of u8 range")); } - limb_bytes[k] = u8::try_from(b).expect("range-checked above"); + *byte = u8::try_from(b).expect("range-checked above"); } limbs.push(u64::from_le_bytes(limb_bytes)); - ptr = key[9]; + ptr = key.at(9); } } @@ -1053,7 +1314,7 @@ fn biguint_to_klimbs_u64(n: &num_bigint::BigUint) -> Vec { /// Build a `List` chain in `memory[10]` from `limbs` (head-first order) /// and return the head pointer. Each entry is inserted with multiplicity 0 /// (unconstrained); subsequent constrained `Load`s by the kernel will bump -/// the multiplicity. Content-addressed via `QueryMap::get_mut`, so repeated +/// the multiplicity. Content-addressed via `QueryMap::get`, so repeated /// identical sub-tails share storage. fn build_klimbs_u64( memory: &mut FxIndexMap, @@ -1065,11 +1326,11 @@ fn build_klimbs_u64( // Find or insert the Nil ptr (tag = 1, padded payload all zero). let nil_key: Vec = std::iter::once(G::ONE).chain((0..9).map(|_| G::ZERO)).collect(); - let mut tail_ptr = if let Some(out) = queries.get_mut(&nil_key) { - out.output[0] + let mut tail_ptr = if let Some(out) = queries.get(&nil_key) { + out.output.at(0) } else { let ptr = G::from_usize(queries.len()); - queries.insert(&nil_key, &[ptr], G::ZERO); + queries.insert(&nil_key, &[ptr], G::ZERO).map_err(|e| e.to_string())?; ptr }; // Walk limbs in REVERSE so each Cons points at the previously-built tail. @@ -1081,32 +1342,35 @@ fn build_klimbs_u64( key.push(G::from_u8(*b)); } key.push(tail_ptr); - tail_ptr = if let Some(out) = queries.get_mut(&key) { - out.output[0] + tail_ptr = if let Some(out) = queries.get(&key) { + out.output.at(0) } else { let ptr = G::from_usize(queries.len()); - queries.insert(&key, &[ptr], G::ZERO); + queries.insert(&key, &[ptr], G::ZERO).map_err(|e| e.to_string())?; ptr }; } Ok(tail_ptr) } -/// Approximate retained bytes of a record's query maps: field elements -/// (keys + outputs) at 8 bytes plus ~21 bytes of per-entry index +/// Approximate retained bytes of a record's query maps: losslessly encoded +/// key/output payload plus ~21 bytes of per-entry index /// overhead (hash-table slot, stored hash, multiplicity). Feeds the /// witness phase of the prover RAM model /// ([`crate::synthesis::AiurSystem::peak_prove_bytes`]). pub fn record_retained_bytes(record: &QueryRecord) -> usize { - let mut elems = 0usize; + let mut payload = 0usize; let mut entries = 0usize; for m in &record.function_queries { - elems += m.retained_elems(); + payload += m.retained_bytes(); entries += m.len(); } for (_, m) in &record.memory_queries { - elems += m.retained_elems(); + payload += m.retained_bytes(); entries += m.len(); } - elems * 8 + entries * 21 + payload + entries * 21 } + +#[cfg(test)] +mod byte_tests; diff --git a/crates/aiur/src/execute/budget.rs b/crates/aiur/src/execute/budget.rs new file mode 100644 index 000000000..3ec8784a1 --- /dev/null +++ b/crates/aiur/src/execute/budget.rs @@ -0,0 +1,141 @@ +//! Cooperative limits for retained execution data, NOT validity judgments. +//! A child budget belongs to one record; its parent bounds all live records. +//! Reservations are made before query-arena/table growth and released on drop. +//! These conservative accounting limits supplement, not replace, an OS cap: +//! stacks, allocator fragmentation and witness construction also consume RAM. + +use std::sync::{ + Arc, Mutex, + atomic::{AtomicU64, Ordering}, +}; + +#[derive(Clone, Debug, PartialEq, Eq)] +pub struct BudgetExceeded { + pub shared: bool, + pub used: u64, + pub requested: u64, + pub limit: u64, +} + +impl std::fmt::Display for BudgetExceeded { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "{} execution memory limit: {} accounted + {} requested > {} bytes", + if self.shared { "batch" } else { "shard" }, + self.used, + self.requested, + self.limit + ) + } +} + +pub struct ExecutionBudget { + limit: u64, + used: AtomicU64, + peak: AtomicU64, + parent: Option>, + failure: Mutex>, + pub label: String, +} + +impl ExecutionBudget { + pub fn new( + limit: u64, + label: String, + parent: Option>, + ) -> Arc { + assert!( + parent.as_ref().is_none_or(|p| p.parent.is_none()), + "execution budgets support one shared parent, not nested hierarchies" + ); + Arc::new(Self { + limit, + label, + parent, + used: AtomicU64::new(0), + peak: AtomicU64::new(0), + failure: Mutex::new(None), + }) + } + + pub fn used(&self) -> u64 { + self.used.load(Ordering::Relaxed) + } + pub fn peak(&self) -> u64 { + self.peak.load(Ordering::Relaxed) + } + pub fn limit(&self) -> u64 { + self.limit + } + pub fn failure(&self) -> Option { + self.failure.lock().unwrap().clone() + } + + fn reserve(&self, bytes: u64, shared: bool) -> Result<(), BudgetExceeded> { + let previous = self + .used + .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |used| { + used.checked_add(bytes).filter(|next| *next <= self.limit) + }) + .map_err(|used| BudgetExceeded { + shared, + used, + requested: bytes, + limit: self.limit, + })?; + self.peak.fetch_max(previous + bytes, Ordering::Relaxed); + Ok(()) + } + + pub fn charge( + self: &Arc, + bytes: u64, + ) -> Result { + let result = self.reserve(bytes, false).and_then(|()| { + if let Some(parent) = &self.parent + && let Err(error) = parent.reserve(bytes, true) + { + self.used.fetch_sub(bytes, Ordering::Relaxed); + return Err(error); + } + Ok(()) + }); + if let Err(error) = result { + *self.failure.lock().unwrap() = Some(error.clone()); + return Err(error); + } + Ok(Charge { budget: Arc::clone(self), bytes }) + } + + pub(crate) fn release(&self, bytes: u64) { + let previous = self.used.fetch_sub(bytes, Ordering::Relaxed); + debug_assert!(previous >= bytes); + if let Some(parent) = &self.parent { + parent.used.fetch_sub(bytes, Ordering::Relaxed); + } + } +} + +pub struct Charge { + budget: Arc, + bytes: u64, +} + +impl Charge { + /// Transfer responsibility for releasing this reservation to its map. + pub(crate) fn retain_bytes(mut self, bytes: u64) { + assert!(bytes <= self.bytes, "execution growth estimate undercharged"); + self.budget.release(self.bytes - bytes); + self.bytes = 0; + } +} + +impl Drop for Charge { + fn drop(&mut self) { + self.budget.release(self.bytes); + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/aiur/src/execute/budget/tests.rs b/crates/aiur/src/execute/budget/tests.rs new file mode 100644 index 000000000..527f8c23b --- /dev/null +++ b/crates/aiur/src/execute/budget/tests.rs @@ -0,0 +1,181 @@ +use super::*; +use crate::{G, querymap::QueryMap}; +use multi_stark::p3_field::PrimeCharacteristicRing; + +#[test] +fn child_and_batch_charges_release_on_drop_and_failure() { + let batch = ExecutionBudget::new(100, "batch".into(), None); + let a = ExecutionBudget::new(80, "a".into(), Some(batch.clone())); + let b = ExecutionBudget::new(80, "b".into(), Some(batch.clone())); + let first = a.charge(70).unwrap(); + assert!(!a.charge(11).err().unwrap().shared); + assert!(b.charge(40).err().unwrap().shared); + assert_eq!((a.used(), b.used(), batch.used()), (70, 0, 70)); + drop(first); + let second = b.charge(80).unwrap(); + assert_eq!(batch.used(), 80); + drop(second); + assert_eq!((a.used(), b.used(), batch.used()), (0, 0, 0)); + assert!( + batch.failure().is_none(), + "one aborted child must not poison siblings" + ); +} + +#[test] +fn map_refuses_growth_before_inserting_or_assigning_a_pointer() { + let budget = ExecutionBudget::new(1, "tiny".into(), None); + let mut map = QueryMap::with_budget(1, Some(budget.clone())); + assert!(map.insert(&[G::ONE], &[G::ZERO], G::ONE).is_err()); + assert_eq!(map.len(), 0); + assert!(map.get_index_of(&[G::ONE]).is_none()); + assert_eq!(budget.used(), 0); +} + +#[test] +fn map_growth_covers_rehash_and_preserves_rows_multiplicities_and_order() { + let budget = ExecutionBudget::new(1 << 30, "record".into(), None); + let mut bounded = QueryMap::with_budget(1, Some(budget.clone())); + let mut reference = QueryMap::new(1); + for n in 0..10_000 { + let key = [G::from_usize(n)]; + let out = [G::from_usize(n + 1)]; + bounded.finish(&key, &out, true).unwrap(); + reference.finish(&key, &out, true).unwrap(); + bounded.finish(&key, &out, true).unwrap(); + reference.finish(&key, &out, true).unwrap(); + assert_eq!(bounded.get_index_of(&key), Some(n)); + assert_eq!(bounded.output_at(n), reference.output_at(n)); + assert_eq!(bounded.mult_at(n), reference.mult_at(n)); + assert_eq!(budget.used(), bounded.accounted_bytes()); + } + assert!(budget.peak() >= budget.used()); + drop(bounded); + assert_eq!(budget.used(), 0); +} + +#[test] +fn dropping_a_record_during_unwind_releases_batch_memory() { + let batch = ExecutionBudget::new(1 << 30, "batch".into(), None); + let held = batch.clone(); + let result = std::panic::catch_unwind(move || { + let record = ExecutionBudget::new(1 << 30, "record".into(), Some(held)); + let mut map = QueryMap::with_budget(0, Some(record)); + map.insert(&[], &[], G::ONE).unwrap(); + panic!("test unwind"); + }); + assert!(result.is_err()); + assert_eq!(batch.used(), 0); +} + +#[test] +fn overflowing_requests_are_rejected_without_wrapping_accounting() { + let budget = ExecutionBudget::new(u64::MAX, "test".into(), None); + let held = budget.charge(u64::MAX).unwrap(); + assert!(budget.charge(1).is_err()); + assert_eq!(budget.used(), u64::MAX); + drop(held); + assert_eq!(budget.used(), 0); +} + +#[test] +fn simultaneous_workers_cannot_overreserve_the_shared_budget() { + let shared = ExecutionBudget::new(100, "batch".into(), None); + let barrier = std::sync::Barrier::new(16); + std::thread::scope(|scope| { + for i in 0..16 { + let shared = shared.clone(); + let barrier = &barrier; + scope.spawn(move || { + let child = + ExecutionBudget::new(100, i.to_string(), Some(shared.clone())); + let held = child.charge(10).ok(); + barrier.wait(); + assert!(shared.used() <= 100); + drop(held); + }); + } + }); + assert_eq!(shared.used(), 0); + assert_eq!(shared.peak(), 100); +} + +#[test] +fn interpreter_propagates_counter_widening_limits_from_call_store_load_and_return() + { + use crate::{ + bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel}, + execute::{ExecError, IOBuffer, QueryRecord}, + }; + let layout = + FunctionLayout { input_size: 1, selectors: 1, auxiliaries: 0, lookups: 1 }; + for op in [ + Some(Op::Call(1, vec![0], 1, false)), + Some(Op::Store(vec![0])), + Some(Op::Load(1, 0)), + None, + ] { + let memory = matches!(op, Some(Op::Store(_) | Op::Load(..))); + let returning = op.is_none(); + let toplevel = Toplevel { + functions: vec![ + Function { + body: Block { + ops: op.into_iter().collect(), + ctrl: Ctrl::Return(0, vec![]), + }, + layout, + entry: true, + constrained: true, + }, + Function { + body: Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) }, + layout, + entry: false, + constrained: true, + }, + ], + memory_sizes: vec![1], + // Only the interpreter and record budgets are exercised here. + circuits: vec![], + }; + let output = if returning { &[][..] } else { &[G::ZERO][..] }; + let mut reference = QueryMap::with_encodings(1, None, true, true); + reference.insert(&[G::ZERO], output, G::from_u32(u32::MAX)).unwrap(); + let budget = ExecutionBudget::new( + reference.accounted_bytes() + (1 << 20), + "counter hit".into(), + None, + ); + let mut limited = + QueryMap::with_encodings(1, Some(budget.clone()), true, true); + limited.insert(&[G::ZERO], output, G::from_u32(u32::MAX)).unwrap(); + let mut record = QueryRecord::new(&toplevel); + if memory { + record.memory_queries[&1] = limited; + } else { + record.function_queries[usize::from(!returning)] = limited; + } + let before = budget.used(); + let error = toplevel.functions[0] + .execute( + 0, + vec![G::ZERO], + &toplevel, + &mut record, + &mut IOBuffer { data: Default::default(), map: Default::default() }, + ) + .unwrap_err(); + assert!(matches!(error, ExecError::ResourceLimit(_))); + let map = if memory { + &record.memory_queries[&1] + } else { + &record.function_queries[usize::from(!returning)] + }; + assert_eq!(map.len(), 1); + assert_eq!(map.mult_at(0), G::from_u32(u32::MAX)); + assert_eq!(budget.used(), before); + drop(record); + assert_eq!(budget.used(), 0); + } +} diff --git a/crates/aiur/src/execute/byte_tests.rs b/crates/aiur/src/execute/byte_tests.rs new file mode 100644 index 000000000..7811e4e4a --- /dev/null +++ b/crates/aiur/src/execute/byte_tests.rs @@ -0,0 +1,225 @@ +use super::*; +use crate::bytecode::FunctionLayout; + +fn empty_record() -> QueryRecord { + QueryRecord::new(&Toplevel { + functions: vec![], + memory_sizes: vec![], + circuits: vec![], + }) +} + +fn empty_io() -> IOBuffer { + IOBuffer { data: FxHashMap::default(), map: FxHashMap::default() } +} + +fn trace1(record: &QueryRecord) -> Vec { + let widths: Vec<_> = Bytes1.lookups().iter().map(|l| l.args.len()).collect(); + Bytes1.witness_data(record, &widths).0.values +} + +fn trace2(record: &QueryRecord) -> Vec { + let widths: Vec<_> = Bytes2.lookups().iter().map(|l| l.args.len()).collect(); + Bytes2.witness_data(record, &widths).0.values +} + +#[test] +fn bad_byte_queries_reject_before_mutation_including_second_digit_alias() { + let mut record = empty_record(); + record.bytes1_queries.bump_bit_decomposition(&G::ONE).unwrap(); + record.bytes2_queries.bump_range_check(&G::ONE, &G::ZERO).unwrap(); + let before1 = trace1(&record); + let before2 = trace2(&record); + for value in [G::from_u16(256), G::from_u64(1 << 40), G::NEG_ONE] { + let error = ExecError::U8RangeCheckFailed(value.as_canonical_u64()); + for op in + [Bytes1Op::BitDecomposition, Bytes1Op::ShiftLeft, Bytes1Op::ShiftRight] + { + assert_eq!( + Bytes1.execute(&op, &[value], &mut record), + Err(error.clone()) + ); + } + for (a, b) in [(value, G::ZERO), (G::ZERO, value)] { + for op in [ + Bytes2Op::Xor, + Bytes2Op::Add, + Bytes2Op::Sub, + Bytes2Op::Mul, + Bytes2Op::And, + Bytes2Op::Or, + Bytes2Op::LessThan, + Bytes2Op::XorSplit7, + Bytes2Op::XorSplit4, + ] { + assert_eq!( + Bytes2.execute(&op, &[a, b], &mut record), + Err(error.clone()) + ); + } + assert_eq!( + record.bytes2_queries.bump_range_check(&a, &b), + Err(error.clone()) + ); + } + } + assert_eq!(trace1(&record), before1); + assert_eq!(trace2(&record), before2); +} + +type UnaryHelper = fn(G, &mut QueryRecord) -> Result, ExecError>; +type BinaryHelper = fn(G, G, &mut QueryRecord) -> Result, ExecError>; + +#[test] +fn generated_byte_helpers_match_gadget_outputs_queries_and_typed_errors() { + let unary: [(Bytes1Op, UnaryHelper); 3] = [ + (Bytes1Op::BitDecomposition, |a, r| { + bytes1_bit_decompose_value(a, r).map(Vec::from) + }), + (Bytes1Op::ShiftLeft, |a, r| { + bytes1_shift_left_value(a, r).map(|v| vec![v]) + }), + (Bytes1Op::ShiftRight, |a, r| { + bytes1_shift_right_value(a, r).map(|v| vec![v]) + }), + ]; + let binary: [(Bytes2Op, BinaryHelper); 9] = [ + (Bytes2Op::Xor, |a, b, r| bytes2_xor_value(a, b, r).map(|v| vec![v])), + (Bytes2Op::And, |a, b, r| bytes2_and_value(a, b, r).map(|v| vec![v])), + (Bytes2Op::Or, |a, b, r| bytes2_or_value(a, b, r).map(|v| vec![v])), + (Bytes2Op::LessThan, |a, b, r| { + bytes2_less_than_value(a, b, r).map(|v| vec![v]) + }), + // The gadget returns just the low byte for add/sub; their generated + // helpers additionally return the derived carry/borrow. + (Bytes2Op::Add, |a, b, r| bytes2_add_value(a, b, r).map(|(v, _)| vec![v])), + (Bytes2Op::Sub, |a, b, r| bytes2_sub_value(a, b, r).map(|(v, _)| vec![v])), + (Bytes2Op::Mul, |a, b, r| { + bytes2_mul_value(a, b, r).map(|(a, b)| vec![a, b]) + }), + (Bytes2Op::XorSplit7, |a, b, r| { + bytes2_xor_split7_value(a, b, r).map(|(a, b)| vec![a, b]) + }), + (Bytes2Op::XorSplit4, |a, b, r| { + bytes2_xor_split4_value(a, b, r).map(|(a, b)| vec![a, b]) + }), + ]; + let (mut native, mut interpreted) = (empty_record(), empty_record()); + let inputs = [ + G::ZERO, + G::ONE, + G::from_u8(255), + G::new(G::ORDER_U64 + 7), + G::from_u16(256), + G::new(G::ORDER_U64 + 256), + G::NEG_ONE, + ]; + for (op, helper) in unary { + for a in inputs { + assert_eq!( + helper(a, &mut native), + Bytes1.execute(&op, &[a], &mut interpreted) + ); + } + } + for (op, helper) in binary { + for a in inputs { + for b in inputs { + assert_eq!( + helper(a, b, &mut native), + Bytes2.execute(&op, &[a, b], &mut interpreted) + ); + } + } + } + assert_eq!(trace1(&native), trace1(&interpreted)); + assert_eq!(trace2(&native), trace2(&interpreted)); +} + +fn call_toplevel( + op: Op, + inputs: usize, + outputs: usize, + hint: bool, +) -> Toplevel { + let make = |ops, entry| Function { + body: Block { + ops, + ctrl: Ctrl::Return(0, (inputs..inputs + outputs).collect()), + }, + // Only execution is used here, not synthesis of these fixture layouts. + layout: FunctionLayout { + input_size: inputs, + selectors: 1, + auxiliaries: 1, + lookups: 1, + }, + entry, + constrained: true, + }; + Toplevel { + functions: vec![ + make(vec![Op::Call(1, (0..inputs).collect(), outputs, hint)], true), + make(vec![op], false), + ], + memory_sizes: vec![], + // This fixture tests execution/rejection, not a proving-system layout. + circuits: vec![], + } +} + +#[test] +fn bytecode_rejects_every_bad_binary_operand_in_checked_and_hint_calls() { + type BinaryOp = fn(usize, usize) -> Op; + let ops: [(BinaryOp, usize); 9] = [ + (Op::U8Xor, 1), + (Op::U8Add, 2), + (Op::U8Sub, 2), + (Op::U8Mul, 2), + (Op::U8And, 1), + (Op::U8Or, 1), + (Op::U8LessThan, 1), + (Op::U8XorSplit7, 2), + (Op::U8XorSplit4, 2), + ]; + for (op, outputs) in ops { + for hint in [false, true] { + let tl = call_toplevel(op(0, 1), 2, outputs, hint); + for bad in [G::from_u16(256), G::from_u64(1 << 40), G::NEG_ONE] { + for input in [vec![bad, G::ZERO], vec![G::ZERO, bad]] { + assert_eq!( + tl.execute(0, input, &mut empty_io()).err(), + Some(ExecError::U8RangeCheckFailed(bad.as_canonical_u64())) + ); + } + } + assert!( + tl.execute(0, vec![G::from_u8(255), G::ONE], &mut empty_io()).is_ok() + ); + } + } +} + +#[test] +fn bytecode_unary_rejection_and_unconstrained_range_check_boundary() { + let ops: [(fn(usize) -> Op, usize); 3] = + [(Op::U8BitDecomposition, 8), (Op::U8ShiftLeft, 1), (Op::U8ShiftRight, 1)]; + for (op, outputs) in ops { + let tl = call_toplevel(op(0), 1, outputs, false); + assert_eq!( + tl.execute(0, vec![G::from_u16(256)], &mut empty_io()).err(), + Some(ExecError::U8RangeCheckFailed(256)) + ); + assert!(tl.execute(0, vec![G::from_u8(255)], &mut empty_io()).is_ok()); + } + for hint in [false, true] { + let tl = call_toplevel(Op::U8RangeCheck(0, 1), 2, 0, hint); + let result = + tl.execute(0, vec![G::ZERO, G::from_u16(256)], &mut empty_io()); + if hint { + assert!(result.is_ok(), "unconstrained range checks remain advisory"); + } else { + assert_eq!(result.err(), Some(ExecError::U8RangeCheckFailed(256))); + } + } +} diff --git a/crates/aiur/src/execute/stats.rs b/crates/aiur/src/execute/stats.rs new file mode 100644 index 000000000..08750f040 --- /dev/null +++ b/crates/aiur/src/execute/stats.rs @@ -0,0 +1,181 @@ +//! Optional final-only scans. No per-query instrumentation, unbounded term +//! maps, change to execution results, or use as an admission/prover bound. + +use std::{io::Write, sync::LazyLock, time::Instant}; + +use super::QueryRecord; +use crate::querymap::MultiplicityStats; + +static ENABLED: LazyLock = LazyLock::new(|| { + std::env::var_os("IX_AIUR_MULTIPLICITY_STATS").is_some_and(|s| s == "1") +}); +const TOP_MAPS: usize = 32; + +struct MapStats { + kind: &'static str, + id: usize, + counts: MultiplicityStats, +} + +struct Snapshot { + functions: MultiplicityStats, + memory: MultiplicityStats, + maps: Vec, +} + +impl Snapshot { + fn collect(record: &QueryRecord) -> Self { + let mut snapshot = Self { + functions: MultiplicityStats::default(), + memory: MultiplicityStats::default(), + maps: Vec::new(), + }; + for (kind, id, map) in record + .function_queries + .iter() + .enumerate() + .map(|(i, m)| ("fn", i, m)) + .chain(record.memory_queries.iter().map(|(&w, m)| ("mem", w, m))) + .filter(|(_, _, m)| !m.is_empty()) + { + let counts = map.multiplicity_stats(); + if kind == "fn" { + snapshot.functions.merge(&counts); + } else { + snapshot.memory.merge(&counts); + } + snapshot.maps.push(MapStats { kind, id, counts }); + } + snapshot.maps.sort_unstable_by(|a, b| { + b.counts + .rows() + .cmp(&a.counts.rows()) + .then_with(|| a.kind.cmp(b.kind)) + .then_with(|| a.id.cmp(&b.id)) + }); + snapshot + } + + fn write(&self, out: &mut impl Write, label: &str) -> std::io::Result<()> { + write_counts(out, label, "functions", &self.functions)?; + write_counts(out, label, "memory", &self.memory)?; + for map in self.maps.iter().take(TOP_MAPS) { + write_counts( + out, + label, + &format!("{}{}", map.kind, map.id), + &map.counts, + )?; + } + Ok(()) + } +} + +fn write_counts( + out: &mut impl Write, + label: &str, + map: &str, + counts: &MultiplicityStats, +) -> std::io::Result<()> { + writeln!( + out, + "[aiur-multiplicity] label={label:?} map={map} rows={} counts={:?} segment_maxima={:?} segment_rows={:?} max={} canonical_sum={} full_payload_bytes={} adaptive_payload_lower_bound={} u32_payload_lower_bound={} stored_payload_bytes={} stored_segments_u32_field={:?}", + counts.rows(), + counts.counts, + counts.segments, + counts.segment_rows, + counts.max, + counts.canonical_sum, + counts.full_payload_bytes(), + counts.adaptive_payload_bytes(), + counts.u32_payload_bytes(), + counts.stored_payload_bytes, + counts.stored_segments + ) +} + +impl QueryRecord { + /// `IX_AIUR_MULTIPLICITY_STATS=1`: scan initialized counter rows once on + /// execution return or rejection, while the record still exists. Scratch + /// is O(function/memory-map count), output is capped at 32 maps plus totals. + /// "returned" means execution returned, not that a proof was constructed. + pub fn log_multiplicity_stats(&self, status: &str) { + if !*ENABLED { + return; + } + let started = Instant::now(); + let snapshot = Snapshot::collect(self); + let scan_us = started.elapsed().as_micros(); + let label = self.budget.as_ref().map_or("unbudgeted", |b| b.label.as_str()); + // Keep these few lines together, but never hold stderr during the scan. + // Diagnostics are best effort: a broken output pipe cannot change checking. + let mut out = std::io::stderr().lock(); + let _ = writeln!( + out, + "[aiur-multiplicity] label={label:?} status={status} scan_us={scan_us} maps={} shown={} omitted={} count_bins=0,1,2..255,256..65535,65536..u32max,larger segment_widths=1,2,4,8 snapshot_only=true", + snapshot.maps.len(), + snapshot.maps.len().min(TOP_MAPS), + snapshot.maps.len().saturating_sub(TOP_MAPS) + ); + if let Some(budget) = &self.budget { + // Budget peak includes transient reservations, including a local + // reservation rolled back if the shared parent then refused it. + let _ = writeln!( + out, + "[aiur-multiplicity] label={label:?} accounted_bytes={} reservation_peak_bytes={} record_limit_bytes={}", + budget.used(), + budget.peak(), + budget.limit() + ); + } + let _ = snapshot.write(&mut out, label); + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{G, bytecode::Toplevel, querymap::QueryMap}; + use multi_stark::p3_field::PrimeCharacteristicRing; + + #[test] + fn totals_include_memory_hint_rows_and_leave_records_unchanged() { + let mut record = QueryRecord::new(&Toplevel { + functions: vec![], + memory_sizes: vec![1], + circuits: vec![], + }); + record.function_queries.push(QueryMap::new(1)); + record.function_queries[0].insert(&[G::ONE], &[], G::TWO).unwrap(); + record.memory_queries[&1].insert(&[G::ONE], &[G::ZERO], G::ZERO).unwrap(); + let snapshot = Snapshot::collect(&record); + assert_eq!(snapshot.functions.counts, [0, 0, 1, 0, 0, 0]); + assert_eq!(snapshot.memory.counts, [1, 0, 0, 0, 0, 0]); + let mut output = Vec::new(); + snapshot.write(&mut output, "shard 0").unwrap(); + let text = String::from_utf8(output).unwrap(); + assert!(text.contains("map=memory rows=1 counts=[1, 0, 0, 0, 0, 0]")); + assert_eq!(record.function_queries[0].mult_at(0), G::TWO); + assert_eq!(record.memory_queries[&1].mult_at(0), G::ZERO); + } + + #[test] + fn output_is_capped_and_labels_cannot_inject_lines() { + let counts = + MultiplicityStats { counts: [0, 1, 0, 0, 0, 0], ..Default::default() }; + let snapshot = Snapshot { + functions: counts.clone(), + memory: MultiplicityStats::default(), + maps: (0..1000) + .map(|id| MapStats { kind: "fn", id, counts: counts.clone() }) + .collect(), + }; + let mut output = Vec::new(); + snapshot.write(&mut output, "shard\nnot another event").unwrap(); + let text = String::from_utf8(output).unwrap(); + assert_eq!(text.lines().count(), TOP_MAPS + 2); + assert!(text.contains("map=fn31 ")); + assert!(!text.contains("map=fn32 ")); + assert!(text.lines().all(|line| line.starts_with("[aiur-multiplicity]"))); + } +} diff --git a/crates/aiur/src/gadgets.rs b/crates/aiur/src/gadgets.rs index 8e556f7e9..055be9910 100644 --- a/crates/aiur/src/gadgets.rs +++ b/crates/aiur/src/gadgets.rs @@ -7,7 +7,10 @@ use multi_stark::{ p3_matrix::dense::RowMajorMatrix, }; -use crate::{G, execute::QueryRecord}; +use crate::{ + G, + execute::{ExecError, QueryRecord}, +}; /// A trait representing a generic Aiur gadget. /// @@ -37,7 +40,7 @@ pub(crate) trait AiurGadget { op: &Self::Op, input: &[G], record: &mut QueryRecord, - ) -> Vec; + ) -> Result, ExecError>; /// Returns the lookups associated with this gadget. fn lookups(&self) -> Vec>>; diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index e3acd1552..42d2f3f46 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -6,8 +6,10 @@ use multi_stark::{ }; use crate::{ - G, execute::QueryRecord, gadgets::AiurGadget, u8_bit_decomposition_channel, - u8_shift_left_channel, u8_shift_right_channel, + G, + execute::{ExecError, QueryRecord}, + gadgets::AiurGadget, + u8_bit_decomposition_channel, u8_shift_left_channel, u8_shift_right_channel, }; /// Number of columns in the trace with multiplicities for @@ -81,22 +83,22 @@ impl AiurGadget for Bytes1 { op: &Bytes1Op, input: &[G], record: &mut QueryRecord, - ) -> Vec { + ) -> Result, ExecError> { let byte = &input[0]; - match op { + Ok(match op { Bytes1Op::BitDecomposition => { - record.bytes1_queries.bump_bit_decomposition(byte); + record.bytes1_queries.bump_bit_decomposition(byte)?; Self::bit_decompose(byte) }, Bytes1Op::ShiftLeft => { - record.bytes1_queries.bump_shift_left(byte); + record.bytes1_queries.bump_shift_left(byte)?; vec![Self::shift_left(byte)] }, Bytes1Op::ShiftRight => { - record.bytes1_queries.bump_shift_right(byte); + record.bytes1_queries.bump_shift_right(byte)?; vec![Self::shift_right(byte)] }, - } + }) } fn lookups(&self) -> Vec>> { @@ -217,21 +219,31 @@ impl Bytes1Queries { Self([[G::ZERO; TRACE_WIDTH]; 256]) } - pub(crate) fn bump_bit_decomposition(&mut self, byte: &G) { + pub(crate) fn bump_bit_decomposition( + &mut self, + byte: &G, + ) -> Result<(), ExecError> { self.bump_multiplicity_for(byte, 0) } - pub(crate) fn bump_shift_left(&mut self, byte: &G) { + pub(crate) fn bump_shift_left(&mut self, byte: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(byte, 1) } - pub(crate) fn bump_shift_right(&mut self, byte: &G) { + pub(crate) fn bump_shift_right(&mut self, byte: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(byte, 2) } - pub(crate) fn bump_multiplicity_for(&mut self, byte: &G, col: usize) { - let row = usize::try_from(byte.as_canonical_u64()).unwrap(); - self.0[row][col] += G::ONE; + pub(crate) fn bump_multiplicity_for( + &mut self, + byte: &G, + col: usize, + ) -> Result<(), ExecError> { + let value = byte.as_canonical_u64(); + let row = u8::try_from(value) + .map_err(|_range_error| ExecError::U8RangeCheckFailed(value))?; + self.0[usize::from(row)][col] += G::ONE; + Ok(()) } } diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index e013a6a34..8958a7193 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -6,9 +6,12 @@ use multi_stark::{ }; use crate::{ - G, execute::QueryRecord, gadgets::AiurGadget, u8_add_channel, u8_and_channel, - u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel, - u8_sub_channel, u8_xor_channel, u8_xor_split4_channel, u8_xor_split7_channel, + G, + execute::{ExecError, QueryRecord}, + gadgets::AiurGadget, + u8_add_channel, u8_and_channel, u8_less_than_channel, u8_mul_channel, + u8_or_channel, u8_range_check_channel, u8_sub_channel, u8_xor_channel, + u8_xor_split4_channel, u8_xor_split7_channel, }; /// Number of columns in the trace with multiplicities for @@ -122,52 +125,52 @@ impl AiurGadget for Bytes2 { op: &Bytes2Op, input: &[G], record: &mut QueryRecord, - ) -> Vec { + ) -> Result, ExecError> { let i = &input[0]; let j = &input[1]; - match op { + Ok(match op { Bytes2Op::Xor => { - record.bytes2_queries.bump_xor(i, j); + record.bytes2_queries.bump_xor(i, j)?; vec![Self::xor(i, j)] }, Bytes2Op::Add => { - record.bytes2_queries.bump_add(i, j); + record.bytes2_queries.bump_add(i, j)?; let (r, _o) = Self::add(i, j); vec![r] }, Bytes2Op::Mul => { - record.bytes2_queries.bump_mul(i, j); + record.bytes2_queries.bump_mul(i, j)?; let (lo, hi) = Self::mul(i, j); vec![lo, hi] }, Bytes2Op::Sub => { - record.bytes2_queries.bump_sub(i, j); + record.bytes2_queries.bump_sub(i, j)?; let (r, _u) = Self::sub(i, j); vec![r] }, Bytes2Op::And => { - record.bytes2_queries.bump_and(i, j); + record.bytes2_queries.bump_and(i, j)?; vec![Self::and(i, j)] }, Bytes2Op::Or => { - record.bytes2_queries.bump_or(i, j); + record.bytes2_queries.bump_or(i, j)?; vec![Self::or(i, j)] }, Bytes2Op::LessThan => { - record.bytes2_queries.bump_less_than(i, j); + record.bytes2_queries.bump_less_than(i, j)?; vec![Self::less_than(i, j)] }, Bytes2Op::XorSplit7 => { - record.bytes2_queries.bump_xor_split7(i, j); + record.bytes2_queries.bump_xor_split7(i, j)?; let (hi, lo) = Self::xor_split7(i, j); vec![hi, lo] }, Bytes2Op::XorSplit4 => { - record.bytes2_queries.bump_xor_split4(i, j); + record.bytes2_queries.bump_xor_split4(i, j)?; let (hi, lo) = Self::xor_split4(i, j); vec![hi, lo] }, - } + }) } fn lookups(&self) -> Vec>> { @@ -396,55 +399,87 @@ impl Bytes2Queries { Self(vec![[G::ZERO; TRACE_WIDTH]; 256 * 256].into_boxed_slice()) } - pub(crate) fn bump_xor(&mut self, i: &G, j: &G) { + pub(crate) fn bump_xor(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 0) } - pub(crate) fn bump_add(&mut self, i: &G, j: &G) { + pub(crate) fn bump_add(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 1) } - pub(crate) fn bump_sub(&mut self, i: &G, j: &G) { + pub(crate) fn bump_sub(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 2) } - pub(crate) fn bump_and(&mut self, i: &G, j: &G) { + pub(crate) fn bump_and(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 3) } - pub(crate) fn bump_or(&mut self, i: &G, j: &G) { + pub(crate) fn bump_or(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 4) } - pub(crate) fn bump_less_than(&mut self, i: &G, j: &G) { + pub(crate) fn bump_less_than( + &mut self, + i: &G, + j: &G, + ) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 5) } - pub fn bump_range_check(&mut self, i: &G, j: &G) { + pub fn bump_range_check(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 6) } - pub(crate) fn bump_mul(&mut self, i: &G, j: &G) { + pub(crate) fn bump_mul(&mut self, i: &G, j: &G) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 7) } - pub(crate) fn bump_xor_split7(&mut self, i: &G, j: &G) { + pub(crate) fn bump_xor_split7( + &mut self, + i: &G, + j: &G, + ) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 8) } - pub(crate) fn bump_xor_split4(&mut self, i: &G, j: &G) { + pub(crate) fn bump_xor_split4( + &mut self, + i: &G, + j: &G, + ) -> Result<(), ExecError> { self.bump_multiplicity_for(i, j, 9) } - pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { - let i = usize::try_from(i.as_canonical_u64()).unwrap(); - let j = usize::try_from(j.as_canonical_u64()).unwrap(); - let row = 256 * i + j; - self.0[row][col] += G::ONE; + pub(crate) fn bump_multiplicity_for( + &mut self, + i: &G, + j: &G, + col: usize, + ) -> Result<(), ExecError> { + // Check each digit before mutation: (0, 256) must not alias (1, 0). + Bytes2::validate_inputs(i, j)?; + let i = usize::try_from(i.as_canonical_u64()).expect("validated byte"); + let j = usize::try_from(j.as_canonical_u64()).expect("validated byte"); + self.0[256 * i + j][col] += G::ONE; + Ok(()) } } impl Bytes2 { + /// Pure arithmetic below also populates already-validated witness rows. + /// Execution checks inputs first, including unconstrained calls that + /// previously panicked on failed byte conversion. + #[inline] + pub fn validate_inputs(i: &G, j: &G) -> Result<(), ExecError> { + for value in [i.as_canonical_u64(), j.as_canonical_u64()] { + if value > u64::from(u8::MAX) { + return Err(ExecError::U8RangeCheckFailed(value)); + } + } + Ok(()) + } + #[inline] pub fn xor(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); diff --git a/crates/aiur/src/memory.rs b/crates/aiur/src/memory.rs index c3fd487d0..0d07a63e2 100644 --- a/crates/aiur/src/memory.rs +++ b/crates/aiur/src/memory.rs @@ -11,17 +11,17 @@ use rayon::{ slice::ParallelSliceMut, }; -use crate::{G, execute::QueryRecord, memory_channel}; +use crate::{G, execute::QueryRecord, memory_channel, querymap::QuerySlice}; pub struct Memory { pub(crate) width: usize, } impl Memory { - pub(super) fn lookup_args(size: G, ptr: G, values: &[G]) -> Vec { + pub(super) fn lookup_args(size: G, ptr: G, values: QuerySlice<'_>) -> Vec { let mut args = Vec::with_capacity(3 + values.len()); args.extend([memory_channel(), size, ptr]); - args.extend(values); + args.extend(values.iter()); args } @@ -99,9 +99,13 @@ impl Memory { row[0] = result.multiplicity; row[1] = G::ONE; row[2] = G::from_usize(i); - row[3..].copy_from_slice(values); + values.copy_to_slice(&mut row[3..]); - let args = Self::lookup_args(G::from_usize(size), row[2], &row[3..]); + let args = Self::lookup_args( + G::from_usize(size), + row[2], + QuerySlice::Fields(&row[3..]), + ); row_lookups.pull(0, row[0], &args); }); drop(row_writers); diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index c82df6928..016c2507f 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -1,22 +1,27 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; -use crate::G; +use crate::{ + G, + execute::budget::{BudgetExceeded, ExecutionBudget}, +}; +use std::sync::Arc; + +mod storage; +use storage::PackedStore; +pub use storage::{PackedRow, QuerySlice}; +mod stats; +pub use stats::MultiplicityStats; +mod multiplicity; +use multiplicity::Multiplicities; /// Immutable view of one query entry. #[derive(Clone, Copy)] pub struct QueryRef<'a> { - pub(crate) output: &'a [G], + pub(crate) output: QuerySlice<'a>, pub multiplicity: G, } -/// Mutable view of one query entry: the output is fixed at insertion, -/// only the multiplicity is bumped on memo hits. -pub struct QueryRefMut<'a> { - pub output: &'a [G], - pub multiplicity: &'a mut G, -} - -fn hash_g_slice(key: &[G]) -> u64 { +pub(crate) fn hash_g_slice(key: &[G]) -> u64 { use std::hash::Hasher; let mut h = rustc_hash::FxHasher::default(); for g in key { @@ -25,8 +30,30 @@ fn hash_g_slice(key: &[G]) -> u64 { h.finish() } +/// Immutable arguments and their canonical hash for generated execution. +/// Owning the fixed-size array keeps the hash tied to its values across +/// recursive calls. This is not a cached bucket or permission to skip exact +/// equality checks: tables may rehash while the callee executes. +#[derive(Clone, Copy)] +pub struct QueryKey { + values: [G; N], + hash: u64, +} + +impl QueryKey { + #[inline] + pub fn new(values: [G; N]) -> Self { + Self { hash: hash_g_slice(&values), values } + } + + #[inline] + pub fn values(&self) -> &[G; N] { + &self.values + } +} + /// Entries per storage segment (2^20). Segments are fixed-size, so growth -/// never reallocates or copies: appending past a segment boundary just +/// does not copy older segments: appending past a segment boundary just /// allocates the next segment. This removes the O(len) memmove of a growing /// `Vec` AND its transient 2x memory spike — on kernel-heavy executions the /// arenas reach tens of GB, where a doubling copy is both seconds of pure @@ -67,7 +94,7 @@ impl HugeVec { #[cfg(target_os = "linux")] fn with_capacity(cap: usize) -> Self { assert!(cap > 0, "HugeVec capacity must be positive"); - let bytes = cap * size_of::(); + let bytes = cap.checked_mul(size_of::()).expect("query arena overflow"); let ptr = unsafe { let p = libc::mmap( std::ptr::null_mut(), @@ -146,56 +173,6 @@ impl Drop for HugeVec { } } -/// Append-only segmented arena of fixed-stride `G` entries. Entry `i` lives -/// at segment `i >> SEG_BITS`, offset `(i & SEG_MASK) * stride` — no entry -/// ever straddles a segment. -struct SegStore { - stride: usize, - segs: Vec>, - entries: usize, -} - -impl SegStore { - fn new(stride: usize) -> Self { - Self { stride, segs: Vec::new(), entries: 0 } - } - - #[inline] - fn at(&self, i: usize) -> &[G] { - if self.stride == 0 { - return &[]; - } - let base = (i & SEG_MASK) * self.stride; - self.segs[i >> SEG_BITS].slice(base, self.stride) - } - - #[inline] - fn at_mut(&mut self, i: usize) -> &mut [G] { - if self.stride == 0 { - return &mut []; - } - let base = (i & SEG_MASK) * self.stride; - self.segs[i >> SEG_BITS].slice_mut(base, self.stride) - } - - #[inline] - fn push(&mut self, vals: &[G]) { - debug_assert_eq!(vals.len(), self.stride); - if self.stride != 0 { - let seg = self.entries >> SEG_BITS; - if seg == self.segs.len() { - self.segs.push(HugeVec::with_capacity(SEG_ENTRIES * self.stride)); - } - self.segs[seg].extend_from_slice(vals); - } - self.entries += 1; - } - - fn retained_elems(&self) -> usize { - self.entries * self.stride - } -} - /// Segmented store of per-entry `u64` key hashes. Keeping the hashes lets /// hash-table growth re-insert entries without re-hashing every key from the /// keys arena; table doubling on a multi-GB map used to be a full sequential @@ -231,15 +208,19 @@ impl SegU64s { /// Functionally the insertion-ordered map `args -> (output, multiplicity)` /// it replaces (`FxIndexMap, QueryResult>`) — but every circuit has /// a FIXED key arity and output width, so keys and outputs live in flat -/// segmented `G` arenas addressed by entry index, and the hash table holds +/// segmented arenas addressed by entry index, and the hash table holds /// only `u32` indices. This cuts per-entry overhead from ~130 B (two heap /// `Vec`s + IndexMap bucket + allocator metadata) to the raw field -/// elements plus ~21 B of index + stored hash. The record IS the proof +/// elements plus ~21 B of index + stored hash. Columns retain one, four or +/// eight bytes per field and decode losslessly on access; larger values widen +/// only the active segment. Memory outputs are reconstructed indices. The record IS the proof /// witness, so entries cannot be dropped — only stored compactly; on /// kernel-heavy executions it is the dominant RAM consumer (billions of -/// entries). Segmented storage keeps growth copy-free (no doubling -/// memmove, no transient 2x RSS), stored hashes make table growth a cheap -/// sequential pass, and segments are hugepage-advised (see `advise_huge`). +/// entries). Segmented growth avoids whole-arena doubling; active-segment +/// widening is budgeted before copying. Stored hashes make table growth a +/// sequential pass, and segments are hugepage-advised. +/// Multiplicities optionally use u32 segments with budgeted full-field +/// promotion on insertion or a later hit, preserving field arithmetic. /// /// Entry index == insertion order; memory circuits use it as the pointer /// value, mirroring the old `IndexMap::get_index_of` semantics. @@ -247,25 +228,70 @@ pub struct QueryMap { /// Output width; inferred on first insert (not statically available in /// `FunctionLayout`). out_stride_set: bool, - keys: SegStore, - outs: SegStore, - mults: SegStore, + /// Only memory maps may reconstruct outputs from their insertion index. + implicit_output: bool, + keys: PackedStore, + outs: PackedStore, + mults: Multiplicities, hashes: SegU64s, table: hashbrown::HashTable, + budget: Option>, + charged: u64, } impl QueryMap { pub fn new(key_stride: usize) -> Self { + Self::with_budget(key_stride, None) + } + + pub(crate) fn with_budget( + key_stride: usize, + budget: Option>, + ) -> Self { + Self::with_storage(key_stride, budget, true) + } + + pub(crate) fn with_storage( + key_stride: usize, + budget: Option>, + compact: bool, + ) -> Self { + Self::with_encodings( + key_stride, + budget, + compact, + compact && *multiplicity::COMPACT, + ) + } + + pub(crate) fn with_encodings( + key_stride: usize, + budget: Option>, + compact: bool, + compact_mults: bool, + ) -> Self { Self { out_stride_set: false, - keys: SegStore::new(key_stride), - outs: SegStore::new(0), - mults: SegStore::new(1), + implicit_output: false, + keys: PackedStore::new(key_stride, compact), + outs: PackedStore::new(0, compact), + mults: Multiplicities::new(compact_mults), hashes: SegU64s::new(), table: hashbrown::HashTable::new(), + budget, + charged: 0, } } + pub(crate) fn with_memory_budget( + key_stride: usize, + budget: Option>, + ) -> Self { + let mut map = Self::with_budget(key_stride, budget); + map.implicit_output = true; + map + } + #[inline] pub fn len(&self) -> usize { self.mults.entries @@ -276,117 +302,326 @@ impl QueryMap { self.mults.entries == 0 } - /// Total retained field elements (keys + outputs); used by the + /// Logical field elements (including reconstructed memory outputs); used by the /// `IX_AIUR_QUERY_STATS` RAM-attribution dump. pub fn retained_elems(&self) -> usize { - self.keys.retained_elems() + self.outs.retained_elems() + self.keys.retained_elems() + + if self.implicit_output { + self.len() + } else { + self.outs.retained_elems() + } + } + + /// Encoded key/output payload, excluding hashes, multiplicities and index. + pub fn retained_bytes(&self) -> usize { + self.keys.retained_bytes() + self.outs.retained_bytes() } pub fn get_index_of(&self, key: &[G]) -> Option { + self.get_index_of_hashed(key, hash_g_slice(key)) + } + + #[inline] + pub fn get_prehashed( + &self, + key: &QueryKey, + ) -> Option { + self.get_index_of_hashed(&key.values, key.hash) + } + + // The interpreter's mutable value stack retains its original input prefix; + // it carries this hash in the call frame without cloning those inputs. + pub(crate) fn get_index_of_hashed( + &self, + key: &[G], + hash: u64, + ) -> Option { debug_assert_eq!(key.len(), self.keys.stride); - let hash = hash_g_slice(key); self .table - .find(hash, |&i| self.keys.at(i as usize) == key) + .find(hash, |&i| self.keys.at(i as usize).matches(key)) .map(|&i| i as usize) } pub fn get(&self, key: &[G]) -> Option> { let i = self.get_index_of(key)?; - Some(QueryRef { - output: self.outs.at(i), - multiplicity: self.mults.at(i)[0], - }) - } - - pub fn get_mut(&mut self, key: &[G]) -> Option> { - let i = self.get_index_of(key)?; - Some(QueryRefMut { - output: self.outs.at(i), - multiplicity: &mut self.mults.at_mut(i)[0], - }) + Some(QueryRef { output: self.output_at(i), multiplicity: self.mults.at(i) }) } /// Multiplicity of entry `i`. #[inline] pub fn mult_at(&self, i: usize) -> G { - self.mults.at(i)[0] + self.mults.at(i) } - /// Output slice of entry `i`. + /// Lossless output view of entry `i`. #[inline] - pub fn output_at(&self, i: usize) -> &[G] { - self.outs.at(i) + pub fn output_at(&self, i: usize) -> QuerySlice<'_> { + assert!(i < self.len(), "query output index out of bounds"); + if self.implicit_output { + QuerySlice::Value(G::from_usize(i)) + } else { + self.outs.at(i) + } } - /// Record a constrained memo hit on entry `i`. + /// Record a constrained memo hit on entry `i`. Widening a counter segment + /// is fallible; rejection leaves every counter and its encoding unchanged. #[inline] - pub fn bump_multiplicity(&mut self, i: usize) { - self.mults.at_mut(i)[0] += G::ONE; + pub fn bump_multiplicity(&mut self, i: usize) -> Result<(), BudgetExceeded> { + if self.mults.try_bump(i) { + return Ok(()); + } + self.bump_widened(i) + } + + #[cold] + fn bump_widened(&mut self, i: usize) -> Result<(), BudgetExceeded> { + let plan = self.mults.plan_bump(i); + let reservation = if let Some(budget) = &self.budget { + let next = self + .accounted_bytes() + .saturating_sub(self.mults.accounted_bytes()) + .saturating_add(plan.storage_after) + .saturating_add(plan.transient); + Some(budget.charge(next - self.charged)?) + } else { + None + }; + self.mults.bump_widened(i, plan); + if let Some(reservation) = reservation { + let after = self.accounted_bytes(); + reservation.retain_bytes(after - self.charged); + self.charged = after; + } + Ok(()) } /// Register a function query at `Ctrl::Return`: insert on first /// registration and bump on constrained promotion of a cached hint row. - pub fn finish(&mut self, key: &[G], output: &[G], constrained: bool) { - if let Some(i) = self.get_index_of(key) { + pub fn finish( + &mut self, + key: &[G], + output: &[G], + constrained: bool, + ) -> Result<(), BudgetExceeded> { + self.finish_hashed(key, hash_g_slice(key), output, constrained) + } + + #[inline] + pub fn finish_prehashed( + &mut self, + key: &QueryKey, + output: &[G], + constrained: bool, + ) -> Result<(), BudgetExceeded> { + self.finish_hashed(&key.values, key.hash, output, constrained) + } + + pub(crate) fn finish_hashed( + &mut self, + key: &[G], + hash: u64, + output: &[G], + constrained: bool, + ) -> Result<(), BudgetExceeded> { + if let Some(i) = self.get_index_of_hashed(key, hash) { // The only ordinary way to execute an already cached function is // constrained promotion of an unconstrained hint entry. - debug_assert_eq!(self.outs.at(i), output); + debug_assert!(self.output_at(i).matches(output)); if constrained { - self.bump_multiplicity(i); + self.bump_multiplicity(i)?; } } else { - self.insert(key, output, G::from_bool(constrained)); + self.insert_hashed(key, hash, output, G::from_bool(constrained))?; } + Ok(()) } /// Append a new entry. The key must not already be present: call sites /// only insert on a confirmed miss, and a same-key re-entrant call /// would loop forever before reaching its own insert. - pub fn insert(&mut self, key: &[G], output: &[G], multiplicity: G) { - debug_assert_eq!(key.len(), self.keys.stride); - debug_assert!(self.get_index_of(key).is_none()); + pub fn insert( + &mut self, + key: &[G], + output: &[G], + multiplicity: G, + ) -> Result<(), BudgetExceeded> { + self.insert_hashed(key, hash_g_slice(key), output, multiplicity) + } + + /// Insert on a confirmed miss, preserving the existing `insert` contract. + pub fn insert_prehashed( + &mut self, + key: &QueryKey, + output: &[G], + multiplicity: G, + ) -> Result<(), BudgetExceeded> { + self.insert_hashed(&key.values, key.hash, output, multiplicity) + } + + pub(crate) fn insert_hashed( + &mut self, + key: &[G], + hash: u64, + output: &[G], + multiplicity: G, + ) -> Result<(), BudgetExceeded> { + assert_eq!(key.len(), self.keys.stride); + debug_assert!(self.get_index_of_hashed(key, hash).is_none()); + if self.implicit_output { + assert_eq!( + output, + &[G::from_usize(self.len())], + "memory output must equal insertion index" + ); + } else if self.out_stride_set { + assert_eq!(output.len(), self.outs.stride); + } + let key_plan = self.keys.plan(key); + let stored_output = if self.implicit_output { &[][..] } else { output }; + let out_plan = self.outs.plan(stored_output); + let mult_plan = self.mults.plan_append(multiplicity); + // Cover both tables during rehash, and hugepage-rounded arena growth, + // BEFORE touching new pages. A failed charge leaves all query data intact. + let reservation = if let Some(budget) = &self.budget { + let mut next = key_plan + .storage_after + .saturating_add(out_plan.storage_after) + .saturating_add(key_plan.transient) + .saturating_add(out_plan.transient) + .saturating_add(mult_plan.storage_after) + .saturating_add(mult_plan.transient) + .saturating_add(arena_bytes(self.len().saturating_add(1), 1)); + if self.len() == self.table.capacity() { + next = next + .saturating_add(table_bytes(self.table.capacity())) + .saturating_add(table_bytes( + self.table.capacity().saturating_mul(2).saturating_add(1).max(4), + )); + } else { + next = next.saturating_add(table_bytes(self.table.capacity())); + } + if next > self.charged { + Some(budget.charge(next - self.charged)?) + } else { + None + } + } else { + None + }; if !self.out_stride_set { - self.outs.stride = output.len(); + self.outs.stride = stored_output.len(); self.out_stride_set = true; } else { - debug_assert_eq!(output.len(), self.outs.stride); + debug_assert_eq!(stored_output.len(), self.outs.stride); } - let hash = hash_g_slice(key); let i = u32::try_from(self.mults.entries).expect("query map overflow"); - self.keys.push(key); - self.outs.push(output); - self.mults.push(&[multiplicity]); + self.keys.push(key, key_plan); + self.outs.push(stored_output, out_plan); + self.mults.push(multiplicity, mult_plan); self.hashes.push(hash); let hashes = &self.hashes; self.table.insert_unique(hash, i, |&j| hashes.at(j as usize)); + if let Some(reservation) = reservation { + // Keep only steady-state storage; the temporary old table is now gone. + let before = self.charged; + let after = self.accounted_bytes(); + // The reservation includes a conservative upper bound for table growth. + // Retain exactly the new steady-state charge and return its excess. + let added = after.saturating_sub(before); + reservation.retain_bytes(added); + self.charged = after; + } + Ok(()) } - /// Entry at insertion index `i`: the key slice plus a mutable handle on - /// the multiplicity (memory `Load` bumps the pointed-to row's count). - pub fn get_index_mut(&mut self, i: usize) -> Option<(&[G], &mut G)> { - if i >= self.mults.entries { - return None; - } - Some((self.keys.at(i), &mut self.mults.at_mut(i)[0])) + fn storage_bytes(&self) -> u64 { + self + .keys + .accounted_bytes() + .saturating_add(self.outs.accounted_bytes()) + .saturating_add(self.mults.accounted_bytes()) + .saturating_add(arena_bytes(self.len(), 1)) + } + + pub fn accounted_bytes(&self) -> u64 { + self.storage_bytes().saturating_add(table_bytes(self.table.capacity())) } - pub fn get_index(&self, i: usize) -> Option<(&[G], QueryRef<'_>)> { + /// Explicit linear scan of counter storage, without decoding keys/outputs. + /// Intended for final opt-in diagnostics, never a progress-tick hot path. + pub fn multiplicity_stats(&self) -> MultiplicityStats { + MultiplicityStats::of_store(&self.mults) + } + + pub fn get_index(&self, i: usize) -> Option<(QuerySlice<'_>, QueryRef<'_>)> { if i >= self.len() { return None; } Some(( self.keys.at(i), - QueryRef { output: self.outs.at(i), multiplicity: self.mults.at(i)[0] }, + QueryRef { output: self.output_at(i), multiplicity: self.mults.at(i) }, )) } - pub fn iter(&self) -> impl Iterator)> { + pub fn iter(&self) -> impl Iterator, QueryRef<'_>)> { (0..self.len()).map(|i| { ( self.keys.at(i), - QueryRef { output: self.outs.at(i), multiplicity: self.mults.at(i)[0] }, + QueryRef { output: self.output_at(i), multiplicity: self.mults.at(i) }, ) }) } } + +impl Drop for QueryMap { + fn drop(&mut self) { + if let Some(budget) = &self.budget { + // Release accounting only AFTER the physical storage has been dropped. + self.keys.clear_storage(); + self.outs.clear_storage(); + self.mults.segs.clear(); + self.hashes.segs.clear(); + drop(std::mem::replace(&mut self.table, hashbrown::HashTable::new())); + budget.release(self.charged); + } + } +} + +fn arena_bytes(entries: usize, stride: usize) -> u64 { + if entries == 0 || stride == 0 { + return 0; + } + let segment = + (SEG_ENTRIES as u64).saturating_mul(stride as u64).saturating_mul(8); + #[cfg(target_os = "linux")] + { + let whole = (entries >> SEG_BITS) as u64; + let tail = ((entries & SEG_MASK) as u64) + .saturating_mul(stride as u64) + .saturating_mul(8); + whole + .saturating_mul(segment) + .saturating_add(tail.div_ceil(1 << 21).saturating_mul(1 << 21)) + } + #[cfg(not(target_os = "linux"))] + { + (entries.div_ceil(SEG_ENTRIES) as u64).saturating_mul(segment) + } +} + +// HashTable: reserve eight bytes per bucket (index + control + margin), +// plus a page for alignment/control-group padding. Include old + new on grow. +fn table_bytes(capacity: usize) -> u64 { + if capacity == 0 { + return 0; + } + capacity + .checked_next_power_of_two() + .map_or(u64::MAX, |b| (b as u64).saturating_mul(8).saturating_add(4096)) +} + +#[cfg(test)] +mod tests; diff --git a/crates/aiur/src/querymap/multiplicity.rs b/crates/aiur/src/querymap/multiplicity.rs new file mode 100644 index 000000000..2fe980bc0 --- /dev/null +++ b/crates/aiur/src/querymap/multiplicity.rs @@ -0,0 +1,202 @@ +//! Field-valued counters, optionally encoded as u32 until a segment widens. +//! No mutable field references escape: even a memo hit may need a budgeted +//! allocation. Width is per segment, never inferred from trusted metadata. + +use super::{ + G, HugeVec, SEG_BITS, SEG_ENTRIES, SEG_MASK, storage::segment_bytes, +}; +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; +use std::sync::LazyLock; + +pub(super) static COMPACT: LazyLock = LazyLock::new(|| { + std::env::var_os("IX_AIUR_COMPACT_MULTIPLICITIES").is_some_and(|s| s == "1") +}); + +pub(super) enum Segment { + U32(HugeVec), + Field(HugeVec), +} + +impl Segment { + fn new(wide: bool) -> Self { + if wide { + Self::Field(HugeVec::with_capacity(SEG_ENTRIES)) + } else { + Self::U32(HugeVec::with_capacity(SEG_ENTRIES)) + } + } + + pub(super) fn width(&self) -> usize { + match self { + Self::U32(_) => 4, + Self::Field(_) => 8, + } + } + + #[inline] + fn at(&self, row: usize) -> G { + match self { + Self::U32(xs) => G::from_u32(xs.slice(row, 1)[0]), + Self::Field(xs) => xs.slice(row, 1)[0], + } + } + + fn push(&mut self, value: G) { + match self { + Self::U32(xs) => xs + .extend_from_slice(&[u32::try_from(value.as_canonical_u64()) + .expect("counter width checked")]), + Self::Field(xs) => xs.extend_from_slice(&[value]), + } + } +} + +/// A read-only growth estimate. QueryMap reserves old + replacement storage +/// before applying it, then releases the old pages' charge after copying. +pub(super) struct Plan { + wide: bool, + promote: bool, + pub storage_after: u64, + pub transient: u64, + payload_after: usize, +} + +pub(super) struct Multiplicities { + pub segs: Vec, + pub entries: usize, + compact: bool, + storage: u64, + payload: usize, +} + +impl Multiplicities { + pub(super) fn new(compact: bool) -> Self { + Self { segs: Vec::new(), entries: 0, compact, storage: 0, payload: 0 } + } + + #[inline] + pub(super) fn at(&self, i: usize) -> G { + assert!(i < self.entries, "multiplicity index out of bounds"); + self.segs[i >> SEG_BITS].at(i & SEG_MASK) + } + + /// The common hit path allocates nothing and makes no budget reservation. + /// On u32 overflow, return false WITHOUT mutation; the caller must reserve + /// a widening before retrying. Full-width counters keep field arithmetic, + /// including modular wrap (never integer saturation or u32 wrap). + #[inline] + pub(super) fn try_bump(&mut self, i: usize) -> bool { + assert!(i < self.entries, "multiplicity index out of bounds"); + match &mut self.segs[i >> SEG_BITS] { + Segment::U32(xs) => { + let value = &mut xs.slice_mut(i & SEG_MASK, 1)[0]; + if let Some(next) = value.checked_add(1) { + *value = next; + true + } else { + false + } + }, + Segment::Field(xs) => { + xs.slice_mut(i & SEG_MASK, 1)[0] += G::ONE; + true + }, + } + } + + pub(super) fn plan_append(&self, value: G) -> Plan { + let tail = self.entries & SEG_MASK; + let old_width = + if tail == 0 { 0 } else { self.segs.last().unwrap().width() }; + let wide = !self.compact + || old_width == 8 + || u32::try_from(value.as_canonical_u64()).is_err(); + let width = if wide { 8 } else { 4 }; + let promote = tail != 0 && old_width != width; + let old = segment_bytes(tail, old_width); + Plan { + wide, + promote, + storage_after: self + .storage + .saturating_sub(old) + .saturating_add(segment_bytes(tail + 1, width)), + transient: if promote { old } else { 0 }, + payload_after: self + .payload + .saturating_add(width) + .saturating_add(if promote { tail.saturating_mul(4) } else { 0 }), + } + } + + /// Unlike key/output packing, hits can widen ANY segment, not just the tail. + pub(super) fn plan_bump(&self, i: usize) -> Plan { + assert!(i < self.entries, "multiplicity index out of bounds"); + let segment = i >> SEG_BITS; + assert_eq!(self.segs[segment].width(), 4); + assert_eq!(self.at(i), G::from_u32(u32::MAX)); + let rows = self.segment_rows(segment); + let old = segment_bytes(rows, 4); + Plan { + wide: true, + promote: true, + storage_after: self + .storage + .saturating_sub(old) + .saturating_add(segment_bytes(rows, 8)), + transient: old, + payload_after: self.payload.saturating_add(rows.saturating_mul(4)), + } + } + + fn promote(&mut self, segment: usize) { + let rows = self.segment_rows(segment); + let Segment::U32(old) = &self.segs[segment] else { + panic!("counter segment already widened"); + }; + let mut next = HugeVec::with_capacity(SEG_ENTRIES); + for &value in old.slice(0, rows) { + next.extend_from_slice(&[G::from_u32(value)]); + } + // Only now drop the old mapping. QueryMap holds both charges until here. + self.segs[segment] = Segment::Field(next); + } + + // Consume plans so internal callers cannot reuse a stale growth estimate. + #[allow(clippy::needless_pass_by_value)] + pub(super) fn push(&mut self, value: G, plan: Plan) { + if self.entries & SEG_MASK == 0 { + self.segs.push(Segment::new(plan.wide)); + } else if plan.promote { + self.promote(self.entries >> SEG_BITS); + } + self.segs.last_mut().unwrap().push(value); + self.entries += 1; + self.storage = plan.storage_after; + self.payload = plan.payload_after; + } + + #[allow(clippy::needless_pass_by_value)] + pub(super) fn bump_widened(&mut self, i: usize, plan: Plan) { + assert!(plan.promote && plan.wide); + self.promote(i >> SEG_BITS); + assert!(self.try_bump(i)); + self.storage = plan.storage_after; + self.payload = plan.payload_after; + } + + pub(super) fn segment_rows(&self, segment: usize) -> usize { + (self.entries - (segment << SEG_BITS)).min(SEG_ENTRIES) + } + + pub(super) fn accounted_bytes(&self) -> u64 { + self.storage + } + + pub(super) fn retained_bytes(&self) -> usize { + self.payload + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/aiur/src/querymap/multiplicity/tests.rs b/crates/aiur/src/querymap/multiplicity/tests.rs new file mode 100644 index 000000000..4e37181b9 --- /dev/null +++ b/crates/aiur/src/querymap/multiplicity/tests.rs @@ -0,0 +1,259 @@ +use super::*; +use crate::{ + execute::budget::ExecutionBudget, + querymap::{QueryKey, QueryMap}, +}; + +fn append(store: &mut Multiplicities, value: G) { + store.push(value, store.plan_append(value)); +} + +fn bump(store: &mut Multiplicities, i: usize) { + if !store.try_bump(i) { + store.bump_widened(i, store.plan_bump(i)); + } +} + +#[test] +fn canonical_boundaries_and_field_wrap_match_full_width_counters() { + for initial in [ + G::ZERO, + G::ONE, + G::from_u16(255), + G::from_u16(65535), + G::from_u32(u32::MAX - 1), + G::from_u32(u32::MAX), + G::from_u64(1 << 32), + G::NEG_ONE, + G::new(G::ORDER_U64 + 7), + ] { + let mut compact = Multiplicities::new(true); + let mut full = Multiplicities::new(false); + append(&mut compact, initial); + append(&mut full, initial); + let narrow = u32::try_from(initial.as_canonical_u64()).is_ok(); + assert_eq!(compact.retained_bytes(), if narrow { 4 } else { 8 }); + for _ in 0..5 { + assert_eq!(compact.at(0), full.at(0)); + bump(&mut compact, 0); + bump(&mut full, 0); + } + assert_eq!(compact.at(0), initial + G::from_u8(5)); + if initial == G::NEG_ONE { + assert_eq!(compact.segs[0].width(), 8, "do not shrink after field wrap"); + } + } +} + +#[test] +fn overflow_probe_is_read_only_until_widening_is_applied() { + let mut store = Multiplicities::new(true); + append(&mut store, G::from_u32(u32::MAX)); + append(&mut store, G::ONE); + let bytes = store.accounted_bytes(); + for _ in 0..3 { + assert!(!store.try_bump(0)); + let plan = store.plan_bump(0); + assert_eq!(store.at(0), G::from_u32(u32::MAX)); + assert_eq!(store.at(1), G::ONE); + assert_eq!(store.retained_bytes(), 8); + assert_eq!(store.accounted_bytes(), bytes); + assert_eq!(plan.transient, bytes); + } + bump(&mut store, 0); + assert_eq!(store.at(0), G::from_u64(1 << 32)); + assert_eq!(store.at(1), G::ONE); + assert_eq!(store.retained_bytes(), 16); +} + +#[test] +fn old_full_and_partial_segments_widen_independently() { + let mut store = Multiplicities::new(true); + for i in 0..2 * SEG_ENTRIES + 3 { + let value = if i == 0 || i == 2 * SEG_ENTRIES - 1 { + G::from_u32(u32::MAX) + } else { + G::ONE + }; + append(&mut store, value); + } + assert_eq!(store.retained_bytes(), (2 * SEG_ENTRIES + 3) * 4); + // Appending an arbitrary field widens only the partial final segment. + append(&mut store, G::NEG_ONE); + assert_eq!( + store.segs.iter().map(Segment::width).collect::>(), + [4, 4, 8] + ); + bump(&mut store, 0); + assert_eq!( + store.segs.iter().map(Segment::width).collect::>(), + [8, 4, 8] + ); + bump(&mut store, 2 * SEG_ENTRIES - 1); + bump(&mut store, 2 * SEG_ENTRIES + 3); + assert_eq!(store.retained_bytes(), (2 * SEG_ENTRIES + 4) * 8); + for i in 0..store.entries { + let expected = if i == 0 || i == 2 * SEG_ENTRIES - 1 { + G::from_u64(1 << 32) + } else if i == 2 * SEG_ENTRIES + 3 { + G::ZERO + } else { + G::ONE + }; + assert_eq!(store.at(i), expected, "row {i}"); + } + assert_eq!( + store.accounted_bytes(), + 2 * segment_bytes(SEG_ENTRIES, 8) + segment_bytes(4, 8) + ); +} + +#[test] +fn a_wide_segment_does_not_force_new_segments_to_be_wide() { + let mut store = Multiplicities::new(true); + for _ in 0..SEG_ENTRIES - 1 { + append(&mut store, G::ONE); + } + append(&mut store, G::NEG_ONE); + append(&mut store, G::ZERO); + assert_eq!(store.segs.iter().map(Segment::width).collect::>(), [8, 4]); + assert_eq!(store.retained_bytes(), SEG_ENTRIES * 8 + 4); + assert_eq!(store.at(SEG_ENTRIES - 2), G::ONE); + assert_eq!(store.at(SEG_ENTRIES - 1), G::NEG_ONE); + assert_eq!(store.at(SEG_ENTRIES), G::ZERO); +} + +fn rows(map: &QueryMap) -> Vec<(Vec, Vec, G)> { + map + .iter() + .map(|(k, r)| (k.to_vec(), r.output.to_vec(), r.multiplicity)) + .collect() +} + +#[test] +fn failed_insert_and_hit_widening_preserve_rows_layout_and_both_budgets() { + let initial = G::from_u32(u32::MAX); + let mut reference = QueryMap::with_encodings(1, None, true, true); + reference.implicit_output = true; + reference.insert(&[G::ZERO], &[G::ZERO], initial).unwrap(); + let steady = reference.accounted_bytes(); + for shared_failure in [false, true] { + let limit = steady + (1 << 20); // Not enough for the replacement segment. + let shared = ExecutionBudget::new( + if shared_failure { limit } else { 1 << 30 }, + "shared".into(), + None, + ); + let local = ExecutionBudget::new( + if shared_failure { 1 << 30 } else { limit }, + "record".into(), + Some(shared.clone()), + ); + let mut map = QueryMap::with_encodings(1, Some(local.clone()), true, true); + map.implicit_output = true; + map.insert(&[G::ZERO], &[G::ZERO], initial).unwrap(); + let charged = local.used(); + let payload = map.mults.retained_bytes(); + for operation in 0..3 { + let error = match operation { + 0 => map.bump_multiplicity(0).unwrap_err(), + 1 => map + .finish_prehashed(&QueryKey::new([G::ZERO]), &[G::ZERO], true) + .unwrap_err(), + _ => map.insert(&[G::ONE], &[G::ONE], G::NEG_ONE).unwrap_err(), + }; + assert_eq!(error.shared, shared_failure); + assert_eq!(rows(&map), rows(&reference)); + assert_eq!(map.mults.segs[0].width(), 4); + assert_eq!(map.mults.retained_bytes(), payload); + assert_eq!(map.get_index_of(&[G::ONE]), None); + assert_eq!((local.used(), shared.used()), (charged, charged)); + // An unconstrained cache return still needs no allocation or bump. + map.finish(&[G::ZERO], &[G::ZERO], false).unwrap(); + } + drop(map); + assert_eq!((local.used(), shared.used()), (0, 0)); + } +} + +#[test] +fn successful_promotion_accounts_for_coexisting_segments_then_releases_them() { + let shared = ExecutionBudget::new(1 << 30, "shared".into(), None); + let budget = + ExecutionBudget::new(1 << 30, "record".into(), Some(shared.clone())); + let mut map = QueryMap::with_encodings(1, Some(budget.clone()), true, true); + for i in 0..1024 { + map.insert(&[G::from_usize(i)], &[], G::from_u32(u32::MAX)).unwrap(); + } + let before = budget.used(); + let plan = map.mults.plan_bump(0); + let expected_peak = + before - map.mults.accounted_bytes() + plan.storage_after + plan.transient; + map.bump_multiplicity(0).unwrap(); + assert!(budget.peak() >= expected_peak); + assert_eq!(budget.used(), map.accounted_bytes()); + assert_eq!(shared.used(), budget.used()); + for i in 0..1024 { + assert_eq!(map.get_index_of(&[G::from_usize(i)]), Some(i)); + assert_eq!(map.mult_at(i), G::from_u32(u32::MAX) + G::from_bool(i == 0)); + } + drop(map); + assert_eq!((budget.used(), shared.used()), (0, 0)); +} + +#[test] +fn mixed_hint_and_constrained_updates_match_full_records_and_memory_ids() { + for memory in [false, true] { + let mut compact = QueryMap::with_encodings(1, None, true, true); + let mut full = QueryMap::with_encodings(1, None, true, false); + compact.implicit_output = memory; + full.implicit_output = memory; + for i in 0..4096 { + let key = QueryKey::new([G::from_usize(i)]); + let out = [G::from_usize(i)]; + let initial = match i % 7 { + 0 => G::ZERO, + 1 => G::from_u32(u32::MAX), + 2 => G::NEG_ONE, + _ => G::new(G::ORDER_U64 + 1), + }; + for map in [&mut compact, &mut full] { + map.insert_prehashed(&key, &out, initial).unwrap(); + map.finish_prehashed(&key, &out, false).unwrap(); + map.finish_prehashed(&key, &out, true).unwrap(); + map.bump_multiplicity(i).unwrap(); + assert_eq!(map.get_prehashed(&key), Some(i)); + } + } + assert_eq!(rows(&compact), rows(&full)); + assert_eq!(compact.mults.retained_bytes(), full.mults.retained_bytes()); + } +} + +#[test] +#[ignore = "matched counter insertion/random-hit throughput; run explicitly in release mode"] +fn counter_storage_and_update_throughput() { + use std::{hint::black_box, time::Instant}; + for round in 0..4 { + for compact in if round % 2 == 0 { [false, true] } else { [true, false] } { + let mut store = Multiplicities::new(compact); + let started = Instant::now(); + for _ in 0..4 * SEG_ENTRIES { + append(&mut store, black_box(G::ONE)); + } + let insert_us = started.elapsed().as_micros(); + let started = Instant::now(); + for i in 0..16 * SEG_ENTRIES { + let index = black_box(i.wrapping_mul(7919) & (4 * SEG_ENTRIES - 1)); + assert!(store.try_bump(index)); + } + let hit_us = started.elapsed().as_micros(); + assert!((0..store.entries).all(|i| store.at(i) == G::from_u8(5))); + eprintln!( + "counter round={round} compact={compact} insert_us={insert_us} hit_us={hit_us} payload={} accounted={}", + store.retained_bytes(), + store.accounted_bytes() + ); + } + } +} diff --git a/crates/aiur/src/querymap/stats.rs b/crates/aiur/src/querymap/stats.rs new file mode 100644 index 000000000..f65d9f812 --- /dev/null +++ b/crates/aiur/src/querymap/stats.rs @@ -0,0 +1,232 @@ +//! Read-only, fixed-size multiplicity distributions for representation studies. +//! These snapshots do not count mutations or remember past segment maxima. + +use super::{ + PrimeField64, + multiplicity::{Multiplicities, Segment}, +}; + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +pub struct MultiplicityStats { + /// Disjoint canonical-value bins: 0, 1, 2..255, 256..65535, + /// 65536..u32::MAX, and larger field values. + pub counts: [u64; 6], + /// Segment maxima fitting in u8/u16/u32/full field, disjoint bins. + pub segments: [u64; 4], + /// Initialized rows in those segments (including the partial last segment). + pub segment_rows: [u64; 4], + pub max: u64, + /// Sum of canonical field values, NOT a lifetime update/call count: + /// hint initialization and modular wrap mean those are different quantities. + pub canonical_sum: u128, + /// Actual initialized payload, including segments kept wide after wrap. + /// Excludes unused capacity, page rounding, and allocation metadata. + pub stored_payload_bytes: u64, + /// Actual segment encodings: u32, full field (not snapshot maxima). + pub stored_segments: [u64; 2], +} + +impl MultiplicityStats { + pub(super) fn of_store(store: &Multiplicities) -> Self { + let mut result = Self { + stored_payload_bytes: store.retained_bytes() as u64, + ..Default::default() + }; + for (i, segment) in store.segs.iter().enumerate() { + let rows = store.segment_rows(i); + let mut max = 0; + let mut observe = |value: u64| { + let bin = match value { + 0 => 0, + 1 => 1, + 2..=255 => 2, + 256..=65535 => 3, + 65536..=0xffff_ffff => 4, + _ => 5, + }; + result.counts[bin] += 1; + result.canonical_sum += u128::from(value); + max = max.max(value); + }; + match segment { + Segment::U32(xs) => { + for &value in xs.slice(0, rows) { + observe(u64::from(value)); + } + result.stored_segments[0] += 1; + }, + Segment::Field(xs) => { + for value in xs.slice(0, rows) { + observe(value.as_canonical_u64()); + } + result.stored_segments[1] += 1; + }, + } + let bin = match max { + 0..=255 => 0, + 256..=65535 => 1, + 65536..=0xffff_ffff => 2, + _ => 3, + }; + result.segments[bin] += 1; + result.segment_rows[bin] += u64::try_from(rows).expect("segment rows"); + result.max = result.max.max(max); + } + debug_assert_eq!(result.rows(), store.entries as u64); + result + } + + pub fn rows(&self) -> u64 { + self.counts.iter().sum() + } + + /// Equivalent full-field payload, excluding allocator/page rounding. + pub fn full_payload_bytes(&self) -> u64 { + self.rows() * 8 + } + + /// Hypothetical segment-wide u8/u16/u32/field encoding of this snapshot. + /// A lower bound, not a measured allocation: ignores spare capacity, + /// metadata, page rounding and historical widening before field wrap. + pub fn adaptive_payload_bytes(&self) -> u64 { + self.segment_rows.iter().zip([1, 2, 4, 8]).map(|(n, b)| n * b).sum() + } + + /// Same snapshot lower bound for u32 segments promoted to full fields. + pub fn u32_payload_bytes(&self) -> u64 { + (self.rows() - self.segment_rows[3]) * 4 + self.segment_rows[3] * 8 + } + + pub fn merge(&mut self, other: &Self) { + for (a, b) in self.counts.iter_mut().zip(&other.counts) { + *a += b; + } + for (a, b) in self.segments.iter_mut().zip(&other.segments) { + *a += b; + } + for (a, b) in self.segment_rows.iter_mut().zip(&other.segment_rows) { + *a += b; + } + self.max = self.max.max(other.max); + self.canonical_sum += other.canonical_sum; + self.stored_payload_bytes += other.stored_payload_bytes; + for (a, b) in self.stored_segments.iter_mut().zip(&other.stored_segments) { + *a += b; + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::{ + G, + querymap::{QueryMap, SEG_ENTRIES}, + }; + use multi_stark::p3_field::PrimeCharacteristicRing; + + #[test] + fn empty_and_boundary_values_use_disjoint_canonical_bins() { + let mut store = Multiplicities::new(true); + assert_eq!( + MultiplicityStats::of_store(&store), + MultiplicityStats::default() + ); + let values = [ + 0, + 1, + 2, + 255, + 256, + 65535, + 65536, + 0xffff_ffff, + 0x1_0000_0000, + G::ORDER_U64 - 1, + G::ORDER_U64 + 1, + ]; + for value in values { + let value = G::new(value); + store.push(value, store.plan_append(value)); + } + let stats = MultiplicityStats::of_store(&store); + assert_eq!(stats.counts, [1, 2, 2, 2, 2, 2]); + assert_eq!(stats.segments, [0, 0, 0, 1]); + assert_eq!(stats.segment_rows, [0, 0, 0, 11]); + assert_eq!(stats.max, G::ORDER_U64 - 1); + assert_eq!( + stats.canonical_sum, + values.into_iter().map(|v| u128::from(v % G::ORDER_U64)).sum::() + ); + assert_eq!(stats.full_payload_bytes(), 88); + assert_eq!(stats.adaptive_payload_bytes(), 88); + assert_eq!(stats.u32_payload_bytes(), 88); + } + + #[test] + fn segment_boundaries_and_late_counter_updates_are_observed() { + let mut store = Multiplicities::new(true); + let boundary = G::from_u32(u32::MAX); + store.push(boundary, store.plan_append(boundary)); + for _ in 1..SEG_ENTRIES { + store.push(G::ONE, store.plan_append(G::ONE)); + } + let value = G::from_u16(256); + store.push(value, store.plan_append(value)); + let stats = MultiplicityStats::of_store(&store); + let full = u64::try_from(SEG_ENTRIES).unwrap(); + assert_eq!(stats.segments, [0, 1, 1, 0]); + assert_eq!(stats.segment_rows, [0, 1, full, 0]); + assert_eq!(stats.adaptive_payload_bytes(), full * 4 + 2); + assert_eq!(stats.u32_payload_bytes(), (full + 1) * 4); + assert!(!store.try_bump(0)); + store.bump_widened(0, store.plan_bump(0)); + let wide = MultiplicityStats::of_store(&store); + assert_eq!(wide.segments, [0, 1, 0, 1]); + assert_eq!(wide.segment_rows, [0, 1, 0, full]); + assert_eq!(wide.u32_payload_bytes(), full * 8 + 4); + assert_eq!(wide.stored_payload_bytes, full * 8 + 4); + store.push(G::NEG_ONE, store.plan_append(G::NEG_ONE)); + assert!(store.try_bump(SEG_ENTRIES + 1)); + let wrapped = MultiplicityStats::of_store(&store); + // Snapshot maxima shrink after wrap, but allocated widths do not. + assert_eq!(wrapped.segment_rows, [0, 2, 0, full]); + assert_eq!(wrapped.stored_segments, [0, 2]); + assert_eq!(wrapped.stored_payload_bytes, (full + 2) * 8); + assert_eq!(wrapped.u32_payload_bytes(), full * 8 + 2 * 4); + } + + #[test] + fn snapshots_observe_all_mutation_apis_without_changing_queries() { + let mut map = QueryMap::new(1); + map.insert(&[G::ZERO], &[G::ONE], G::ZERO).unwrap(); + map.insert(&[G::ONE], &[G::TWO], G::from_u8(255)).unwrap(); + map.finish(&[G::ZERO], &[G::ONE], true).unwrap(); + map.bump_multiplicity(1).unwrap(); + map.insert(&[G::TWO], &[G::ZERO], G::NEG_ONE).unwrap(); + map.bump_multiplicity(2).unwrap(); + let before = map + .iter() + .map(|(k, r)| (k.to_vec(), r.output.to_vec(), r.multiplicity)) + .collect::>(); + let stats = map.multiplicity_stats(); + assert_eq!(stats.counts, [1, 1, 0, 1, 0, 0]); + assert_eq!(stats.segment_rows, [0, 3, 0, 0]); + assert_eq!(stats.canonical_sum, 257); + assert_eq!( + before, + map + .iter() + .map(|(k, r)| (k.to_vec(), r.output.to_vec(), r.multiplicity)) + .collect::>() + ); + let mut aggregate = MultiplicityStats::default(); + aggregate.merge(&stats); + aggregate.merge(&stats); + assert_eq!(aggregate.counts, [2, 2, 0, 2, 0, 0]); + assert_eq!(aggregate.segment_rows, [0, 6, 0, 0]); + assert_eq!(aggregate.canonical_sum, 514); + assert_eq!(aggregate.stored_payload_bytes, 2 * stats.stored_payload_bytes); + assert_eq!(aggregate.max, 256); + } +} diff --git a/crates/aiur/src/querymap/storage.rs b/crates/aiur/src/querymap/storage.rs new file mode 100644 index 000000000..b5c20e215 --- /dev/null +++ b/crates/aiur/src/querymap/storage.rs @@ -0,0 +1,439 @@ +//! Lossless, per-column byte/u32/full-field query storage. Encoding is selected +//! from actual canonical values, never trusted type/name metadata. Widening +//! copies only the active segment and preserves row indices and memo hashes. + +use super::{G, HugeVec, SEG_BITS, SEG_ENTRIES, SEG_MASK}; +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; + +/// A packed row borrows its segment's immutable layout. All accesses decode +/// through checked byte slices, including unaligned u32/full-field columns. +#[derive(Clone, Copy, Debug)] +pub struct PackedRow<'a> { + bytes: &'a [u8], + layout: &'a MixedLayout, +} + +impl PackedRow<'_> { + fn at(self, i: usize) -> G { + let column = &self.layout.columns[i]; + let bytes = + &self.bytes[column.offset..column.offset + column.width.bytes()]; + match column.width { + Width::Byte => G::from_u8(bytes[0]), + Width::U32 => G::from_u32(u32::from_le_bytes(bytes.try_into().unwrap())), + Width::Field => { + G::from_u64(u64::from_le_bytes(bytes.try_into().unwrap())) + }, + } + } +} + +/// Read-only field view. No second full-width copy is retained and generated +/// cache hits decode straight into stack arrays. Value represents a memory +/// pointer reconstructed from the insertion index, not a stored output. +#[derive(Clone, Copy, Debug)] +pub enum QuerySlice<'a> { + Fields(&'a [G]), + Bytes(&'a [u8]), + Packed(PackedRow<'a>), + Value(G), +} + +impl QuerySlice<'_> { + pub fn len(self) -> usize { + match self { + Self::Fields(xs) => xs.len(), + Self::Bytes(xs) => xs.len(), + Self::Packed(row) => row.layout.columns.len(), + Self::Value(_) => 1, + } + } + + pub fn is_empty(self) -> bool { + self.len() == 0 + } + + #[inline] + pub fn at(self, i: usize) -> G { + match self { + Self::Fields(xs) => xs[i], + Self::Bytes(xs) => G::from_u8(xs[i]), + Self::Packed(row) => row.at(i), + Self::Value(value) => { + assert_eq!(i, 0); + value + }, + } + } + + pub fn iter(self) -> impl ExactSizeIterator + DoubleEndedIterator { + (0..self.len()).map(move |i| self.at(i)) + } + + #[inline] + pub fn matches(self, other: &[G]) -> bool { + match self { + Self::Fields(xs) => xs == other, + Self::Bytes(xs) => { + xs.len() == other.len() + && xs + .iter() + .zip(other) + .all(|(&a, b)| u64::from(a) == b.as_canonical_u64()) + }, + _ => { + self.len() == other.len() + && self.iter().zip(other).all(|(a, b)| a == *b) + }, + } + } + + #[inline] + pub fn copy_to_slice(self, dst: &mut [G]) { + assert_eq!(self.len(), dst.len(), "query slice width mismatch"); + match self { + Self::Fields(xs) => dst.copy_from_slice(xs), + _ => { + for (out, value) in dst.iter_mut().zip(self.iter()) { + *out = value; + } + }, + } + } + + #[inline] + pub fn to_array(self) -> [G; N] { + assert_eq!(self.len(), N, "query array width mismatch"); + match self { + Self::Fields(xs) => xs.try_into().expect("width checked above"), + _ => std::array::from_fn(|i| self.at(i)), + } + } + + pub fn to_vec(self) -> Vec { + match self { + Self::Fields(xs) => xs.to_vec(), + _ => self.iter().collect(), + } + } +} + +impl PartialEq for QuerySlice<'_> { + fn eq(&self, other: &Self) -> bool { + match (*self, *other) { + (Self::Fields(a), b) | (b, Self::Fields(a)) => b.matches(a), + (Self::Bytes(a), Self::Bytes(b)) => a == b, + (a, b) => a.len() == b.len() && a.iter().eq(b.iter()), + } + } +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +enum Width { + Byte, + U32, + Field, +} + +impl Width { + fn needed(value: G) -> Self { + let value = value.as_canonical_u64(); + if u8::try_from(value).is_ok() { + Self::Byte + } else if u32::try_from(value).is_ok() { + Self::U32 + } else { + Self::Field + } + } + + fn bytes(self) -> usize { + match self { + Self::Byte => 1, + Self::U32 => 4, + Self::Field => 8, + } + } + + fn fits(self, value: G) -> bool { + match self { + Self::Byte => u8::try_from(value.as_canonical_u64()).is_ok(), + Self::U32 => u32::try_from(value.as_canonical_u64()).is_ok(), + Self::Field => true, + } + } +} + +#[derive(Clone, Debug)] +struct Column { + offset: usize, + width: Width, +} + +#[derive(Clone, Debug)] +struct MixedLayout { + columns: Vec, + bytes: usize, +} + +#[derive(Clone)] +enum Layout { + Bytes(usize), + Fields(usize), + Mixed(MixedLayout), +} + +impl Layout { + fn new(stride: usize, compact: bool) -> Self { + if compact { Self::Bytes(stride) } else { Self::Fields(stride) } + } + + fn bytes(&self) -> usize { + match self { + Self::Bytes(n) => *n, + Self::Fields(n) => { + n.checked_mul(size_of::()).expect("query row overflow") + }, + Self::Mixed(layout) => layout.bytes, + } + } + + fn fits(&self, vals: &[G]) -> bool { + match self { + Self::Bytes(_) => vals.iter().all(|&v| Width::Byte.fits(v)), + Self::Fields(_) => true, + Self::Mixed(layout) => { + layout.columns.iter().zip(vals).all(|(c, &v)| c.width.fits(v)) + }, + } + } + + /// Called only on initial width inference or a range miss. No per-row heap + /// allocation on the ordinary insertion path. Column widths never shrink. + fn widened(&self, vals: &[G]) -> Self { + let mut bytes = 0usize; + let mut all_bytes = true; + let mut all_fields = true; + let columns = vals + .iter() + .enumerate() + .map(|(i, &v)| { + let old = match self { + Self::Bytes(_) => Width::Byte, + Self::Fields(_) => Width::Field, + Self::Mixed(layout) => layout.columns[i].width, + }; + let width = old.max(Width::needed(v)); + all_bytes &= width == Width::Byte; + all_fields &= width == Width::Field; + let offset = bytes; + bytes = bytes.checked_add(width.bytes()).expect("query row overflow"); + Column { offset, width } + }) + .collect(); + if all_bytes { + Self::Bytes(vals.len()) + } else if all_fields { + Self::Fields(vals.len()) + } else { + Self::Mixed(MixedLayout { columns, bytes }) + } + } +} + +enum Segment { + Bytes(HugeVec), + Fields(HugeVec), + Mixed { data: HugeVec, layout: MixedLayout }, +} + +impl Segment { + fn new(layout: &Layout) -> Self { + let capacity = |width: usize| { + SEG_ENTRIES.checked_mul(width).expect("query segment overflow") + }; + match layout { + Layout::Bytes(n) => Self::Bytes(HugeVec::with_capacity(capacity(*n))), + Layout::Fields(n) => Self::Fields(HugeVec::with_capacity(capacity(*n))), + Layout::Mixed(layout) => Self::Mixed { + data: HugeVec::with_capacity(capacity(layout.bytes)), + layout: layout.clone(), + }, + } + } + + fn at(&self, row: usize, stride: usize) -> QuerySlice<'_> { + match self { + Self::Bytes(xs) => QuerySlice::Bytes(xs.slice(row * stride, stride)), + Self::Fields(xs) => QuerySlice::Fields(xs.slice(row * stride, stride)), + Self::Mixed { data, layout } => QuerySlice::Packed(PackedRow { + bytes: data.slice(row * layout.bytes, layout.bytes), + layout, + }), + } + } + + fn push(&mut self, row: QuerySlice<'_>) { + match self { + Self::Bytes(xs) => match row { + QuerySlice::Bytes(bytes) => xs.extend_from_slice(bytes), + _ => { + for v in row.iter() { + xs.extend_from_slice(&[ + u8::try_from(v.as_canonical_u64()).expect("byte width checked") + ]); + } + }, + }, + Self::Fields(xs) => match row { + QuerySlice::Fields(fields) => xs.extend_from_slice(fields), + _ => { + for v in row.iter() { + xs.extend_from_slice(&[v]); + } + }, + }, + Self::Mixed { data, layout } => { + assert_eq!(row.len(), layout.columns.len()); + for (column, value) in layout.columns.iter().zip(row.iter()) { + // Check again at the encoding boundary: no unchecked narrowing or + // type-based trust, even if an internal caller supplied a bad plan. + assert!(column.width.fits(value), "packed column width checked"); + let bytes = value.as_canonical_u64().to_le_bytes(); + data.extend_from_slice(&bytes[..column.width.bytes()]); + } + }, + } + } +} + +pub(super) struct AppendPlan { + layout: Option, + pub storage_after: u64, + /// Old pages coexist with their replacement while the active segment widens. + pub transient: u64, + payload_after: usize, +} + +pub(super) struct PackedStore { + pub stride: usize, + entries: usize, + segs: Vec, + layout: Layout, + storage: u64, + payload: usize, +} + +impl PackedStore { + pub(super) fn new(stride: usize, compact: bool) -> Self { + Self { + stride, + entries: 0, + segs: Vec::new(), + layout: Layout::new(stride, compact), + storage: 0, + payload: 0, + } + } + + #[inline] + pub(super) fn at(&self, i: usize) -> QuerySlice<'_> { + assert!(i < self.entries, "query index out of bounds"); + if self.stride == 0 { + return QuerySlice::Fields(&[]); + } + self.segs[i >> SEG_BITS].at(i & SEG_MASK, self.stride) + } + + /// Plan growth without changing data or the current layout. Refused budget + /// reservations leave rows, indices, multiplicities and encoding untouched. + pub(super) fn plan(&self, vals: &[G]) -> AppendPlan { + assert!(self.entries == 0 || vals.len() == self.stride); + let layout = if (self.entries == 0 && vals.len() != self.stride) + || !self.layout.fits(vals) + { + Some(self.layout.widened(vals)) + } else { + None + }; + let next_layout = layout.as_ref().unwrap_or(&self.layout); + let tail = self.entries & SEG_MASK; + let old = + if tail == 0 { 0 } else { segment_bytes(tail, self.layout.bytes()) }; + let next = segment_bytes(tail + 1, next_layout.bytes()); + let promote = tail != 0 && layout.is_some(); + let payload_after = self + .payload + .saturating_add(next_layout.bytes()) + .saturating_add(if promote { + tail.saturating_mul(next_layout.bytes() - self.layout.bytes()) + } else { + 0 + }); + AppendPlan { + layout, + storage_after: self.storage.saturating_sub(old).saturating_add(next), + transient: if promote { old } else { 0 }, + payload_after, + } + } + + pub(super) fn push(&mut self, vals: &[G], plan: AppendPlan) { + if self.entries == 0 { + self.stride = vals.len(); + } + assert_eq!(vals.len(), self.stride); + let changed = plan.layout.is_some(); + if let Some(layout) = plan.layout { + self.layout = layout; + } + if self.stride != 0 { + let tail = self.entries & SEG_MASK; + if tail == 0 { + self.segs.push(Segment::new(&self.layout)); + } else if changed { + let old = self.segs.last().unwrap(); + let mut next = Segment::new(&self.layout); + for row in 0..tail { + next.push(old.at(row, self.stride)); + } + *self.segs.last_mut().unwrap() = next; + } + self.segs.last_mut().unwrap().push(QuerySlice::Fields(vals)); + } + self.entries += 1; + self.storage = plan.storage_after; + self.payload = plan.payload_after; + } + + pub(super) fn accounted_bytes(&self) -> u64 { + self.storage + } + pub(super) fn retained_bytes(&self) -> usize { + self.payload + } + pub(super) fn retained_elems(&self) -> usize { + self.entries * self.stride + } + pub(super) fn clear_storage(&mut self) { + self.segs.clear(); + } +} + +pub(super) fn segment_bytes(entries: usize, row_bytes: usize) -> u64 { + if entries == 0 || row_bytes == 0 { + return 0; + } + #[cfg(target_os = "linux")] + { + (entries as u64) + .saturating_mul(row_bytes as u64) + .div_ceil(1 << 21) + .saturating_mul(1 << 21) + } + #[cfg(not(target_os = "linux"))] + { + let _ = entries; + (SEG_ENTRIES as u64).saturating_mul(row_bytes as u64) + } +} diff --git a/crates/aiur/src/querymap/tests.rs b/crates/aiur/src/querymap/tests.rs new file mode 100644 index 000000000..26d83dce6 --- /dev/null +++ b/crates/aiur/src/querymap/tests.rs @@ -0,0 +1,610 @@ +use super::*; + +fn key(n: u64) -> [G; 16] { + let mut fields = [G::ZERO; 16]; + for (out, byte) in fields.iter_mut().zip(n.to_le_bytes()) { + *out = G::from_u8(byte); + } + fields +} + +fn output(n: u64) -> [G; 9] { + let mut fields = [G::ZERO; 9]; + for (out, byte) in fields.iter_mut().zip(n.wrapping_mul(7919).to_le_bytes()) { + *out = G::from_u8(byte); + } + fields[8] = G::from_bool(n.is_multiple_of(2)); + fields +} + +fn rows(map: &QueryMap) -> Vec<(Vec, Vec, G)> { + map + .iter() + .map(|(k, r)| (k.to_vec(), r.output.to_vec(), r.multiplicity)) + .collect() +} + +// Frozen pre-Q1 registration path for differential tests and timing: the +// caller probes, registration probes again, and insertion hashes once more. +fn legacy_finish( + map: &mut QueryMap, + key: &[G], + output: &[G], + constrained: bool, +) { + if let Some(i) = map.get_index_of(key) { + assert!(map.output_at(i).matches(output)); + if constrained { + map.bump_multiplicity(i).unwrap(); + } + } else { + map.insert(key, output, G::from_bool(constrained)).unwrap(); + } +} + +#[test] +fn prehashed_keys_survive_recursive_growth_and_preserve_hint_promotion() { + let mut cached = QueryMap::new(16); + let mut baseline = QueryMap::new(16); + let pending = QueryKey::new(key(100_000)); + assert_eq!(cached.get_prehashed(&pending), None); + for n in 0..8192 { + let k = QueryKey::new(key(n)); + assert_eq!(cached.get_prehashed(&k), baseline.get_index_of(k.values())); + cached.finish_prehashed(&k, &output(n), false).unwrap(); + legacy_finish(&mut baseline, k.values(), &output(n), false); + } + // Many child inserts have rehashed the table; the saved key is not a bucket. + cached.finish_prehashed(&pending, &output(100_000), true).unwrap(); + legacy_finish(&mut baseline, pending.values(), &output(100_000), true); + for n in (0..8192).rev() { + let k = QueryKey::new(key(n)); + cached.finish_prehashed(&k, &output(n), true).unwrap(); + cached.finish_prehashed(&k, &output(n), true).unwrap(); + legacy_finish(&mut baseline, k.values(), &output(n), true); + legacy_finish(&mut baseline, k.values(), &output(n), true); + } + assert_eq!(rows(&cached), rows(&baseline)); + assert_eq!(cached.accounted_bytes(), baseline.accounted_bytes()); +} + +#[test] +fn prehashed_collisions_still_compare_full_keys_after_rehash() { + let mut map = QueryMap::new(2); + // Exercise the internal collision path with a deliberately constant hash. + // Public QueryKey constructors do not let callers supply a false hash. + for n in 0..128 { + let key = [G::from_u64(n * 256), G::NEG_ONE]; + map.insert_hashed(&key, 7, &[G::from_u64(n)], G::ZERO).unwrap(); + } + for n in 0..128 { + let key = [G::from_u64(n * 256), G::NEG_ONE]; + assert_eq!( + map.get_index_of_hashed(&key, 7), + Some(usize::try_from(n).unwrap()) + ); + map.finish_hashed(&key, 7, &[G::from_u64(n)], true).unwrap(); + assert_eq!(map.mult_at(usize::try_from(n).unwrap()), G::ONE); + } + assert_eq!(map.get_index_of_hashed(&[G::ONE, G::NEG_ONE], 7), None); + assert_eq!(map.get_index_of_hashed(&[G::ZERO, G::ZERO], 7), None); +} + +#[test] +fn prehashed_keys_own_values_and_canonicalize_field_representatives() { + let mut values = [G::new(G::ORDER_U64 + 7)]; + let saved = QueryKey::new(values); + values[0] = G::from_u16(256); + let mut map = QueryMap::new(1); + map.insert_prehashed(&saved, &[], G::ONE).unwrap(); + assert_eq!(map.get_prehashed(&QueryKey::new([G::from_u8(7)])), Some(0)); + assert_eq!(map.get_prehashed(&QueryKey::new(values)), None); + let mut empty = QueryMap::new(0); + let key = QueryKey::new([]); + empty.finish_prehashed(&key, &[], true).unwrap(); + assert_eq!(empty.get_prehashed(&key), Some(0)); +} + +#[test] +fn prehashed_memory_insertion_preserves_budget_atomicity_and_pointer_ids() { + let budget = ExecutionBudget::new(1, "tiny prehash".into(), None); + let mut limited = QueryMap::with_memory_budget(1, Some(budget.clone())); + let key = QueryKey::new([G::ONE]); + assert!(limited.insert_prehashed(&key, &[G::ZERO], G::ONE).is_err()); + assert_eq!(limited.len(), 0); + assert_eq!(limited.get_prehashed(&key), None); + assert_eq!(budget.used(), 0); + let mut memory = QueryMap::with_memory_budget(1, None); + for n in 0..1024 { + let key = QueryKey::new([G::from_usize(n)]); + memory.insert_prehashed(&key, &[G::from_usize(n)], G::ONE).unwrap(); + assert_eq!(memory.get_prehashed(&key), Some(n)); + assert_eq!(memory.output_at(n).at(0), G::from_usize(n)); + } +} + +#[test] +fn interpreter_restores_hashes_across_deep_recursive_returns_and_rehashes() { + use crate::bytecode::{Block, Ctrl, Function, FunctionLayout, Op, Toplevel}; + let layout = + FunctionLayout { input_size: 1, selectors: 2, auxiliaries: 1, lookups: 1 }; + let tl = Toplevel { + functions: vec![ + Function { + body: Block { + ops: vec![Op::Call(1, vec![0], 1, false)], + ctrl: Ctrl::Return(0, vec![1]), + }, + layout, + entry: true, + constrained: true, + }, + Function { + body: Block { + ops: vec![], + ctrl: Ctrl::Match( + 0, + [(G::ZERO, Block { ops: vec![], ctrl: Ctrl::Return(0, vec![0]) })] + .into_iter() + .collect(), + Some(Box::new(Block { + ops: vec![ + Op::Const(G::ONE), + Op::Sub(0, 1), + Op::Call(1, vec![2], 1, false), + Op::Add(0, 3), + ], + ctrl: Ctrl::Return(1, vec![4]), + })), + ), + }, + layout, + entry: false, + constrained: true, + }, + ], + memory_sizes: vec![], + // Interpreter-only regression; no circuit synthesis is requested. + circuits: vec![], + }; + let mut io = crate::execute::IOBuffer { + data: Default::default(), + map: Default::default(), + }; + let (record, out) = + tl.execute(0, vec![G::from_u64(10_000)], &mut io).unwrap(); + assert_eq!(out, vec![G::from_u64(50_005_000)]); + assert_eq!(record.function_queries[1].len(), 10_001); + for n in 0..=10_000 { + let q = record.function_queries[1].get(&[G::from_u64(n)]).unwrap(); + assert_eq!(q.output.at(0), G::from_u64(n * (n + 1) / 2)); + assert_eq!(q.multiplicity, G::ONE); + } +} + +#[test] +#[ignore = "matched query-path throughput; run explicitly in release mode"] +fn prehashed_query_paths_throughput() { + fn bench(cached: bool) -> (u128, u128, u64) { + use std::{hint::black_box, time::Instant}; + let make_key = |n| { + let mut key = [G::ZERO; N]; + key[0] = G::from_usize(n); + key + }; + let mut map = QueryMap::new(N); + let started = Instant::now(); + for n in 0..1_000_000 { + let values = black_box(make_key(n)); + let out = [values[0]]; + if cached { + let key = QueryKey::new(values); + assert!(map.get_prehashed(&key).is_none()); + map.finish_prehashed(&key, &out, true).unwrap(); + } else { + assert!(map.get_index_of(&values).is_none()); + legacy_finish(&mut map, &values, &out, true); + } + } + let insert_us = started.elapsed().as_micros(); + let started = Instant::now(); + for n in (0..1_000_000).rev() { + let values = black_box(make_key(n)); + let i = if cached { + map.get_prehashed(&QueryKey::new(values)) + } else { + map.get_index_of(&values) + } + .unwrap(); + map.bump_multiplicity(i).unwrap(); + assert_eq!(black_box(map.output_at(i).at(0)), values[0]); + } + assert_eq!(map.len(), 1_000_000); + (insert_us, started.elapsed().as_micros(), map.accounted_bytes()) + } + for round in 0..4 { + for cached in if round % 2 == 0 { [false, true] } else { [true, false] } { + eprintln!( + "prehash round={round} cached={cached} key2={:?} key16={:?} key64={:?}", + bench::<2>(cached), + bench::<16>(cached), + bench::<64>(cached) + ); + } + } +} + +#[test] +fn compact_and_full_maps_preserve_keys_outputs_order_and_promotion() { + let mut compact = QueryMap::new(16); + let mut full = QueryMap::with_storage(16, None, false); + for n in 0..65_536 { + let index = usize::try_from(n).unwrap(); + for map in [&mut compact, &mut full] { + map.finish(&key(n), &output(n), false).unwrap(); + assert_eq!(map.mult_at(index), G::ZERO); + map.finish(&key(n), &output(n), true).unwrap(); + map.finish(&key(n), &output(n), true).unwrap(); + assert_eq!(map.get_index_of(&key(n)), Some(index)); + assert_eq!(map.output_at(index).to_array::<9>(), output(n)); + assert_eq!(map.mult_at(index), G::TWO); + } + } + assert_eq!(rows(&compact), rows(&full)); + assert_eq!(compact.retained_bytes(), 65_536 * 25); + assert_eq!(compact.retained_bytes() * 8, full.retained_bytes()); + assert!(compact.accounted_bytes() < full.accounted_bytes()); +} + +#[test] +fn wide_values_are_preserved_and_never_alias_truncated_bytes() { + let mut map = QueryMap::new(1); + for (i, value) in [ + G::ZERO, + G::ONE, + G::from_u8(255), + G::from_u16(256), + G::from_u16(511), + G::from_u64(1 << 56), + G::NEG_ONE, + G::from_u64(u64::MAX), + ] + .into_iter() + .enumerate() + { + map.insert(&[value], &[value], G::from_u16(1000)).unwrap(); + assert_eq!(map.get_index_of(&[value]), Some(i)); + assert_eq!(map.output_at(i).to_array::<1>(), [value]); + map.bump_multiplicity(i).unwrap(); + assert_eq!(map.mult_at(i), G::from_u16(1001)); + } + assert_eq!(map.get_index_of(&[G::ZERO]), Some(0)); + assert_eq!(map.get_index_of(&[G::from_u16(256)]), Some(3)); + assert_eq!(map.get_index_of(&[G::from_u8(255)]), Some(2)); + assert_eq!(map.get_index_of(&[G::from_u16(511)]), Some(4)); + assert!(matches!(map.output_at(0), QuerySlice::Fields(_))); +} + +#[test] +fn noncanonical_field_representatives_hit_the_same_byte_key() { + let mut map = QueryMap::new(1); + let alias = G::new(G::ORDER_U64 + 7); + let canonical = G::from_u8(7); + assert_eq!(alias, canonical); + map.insert(&[alias], &[alias], G::ONE).unwrap(); + assert_eq!(map.get_index_of(&[canonical]), Some(0)); + assert!(matches!(map.output_at(0), QuerySlice::Bytes(_))); + assert_eq!(map.output_at(0).at(0), alias); + map.finish(&[canonical], &[canonical], true).unwrap(); + assert_eq!(map.len(), 1); + assert_eq!(map.mult_at(0), G::TWO); + // An actual wide field forces a lossless promotion; both representatives + // must still resolve to the original row after the storage change. + map.insert(&[G::from_u16(256)], &[G::NEG_ONE], G::ONE).unwrap(); + assert_eq!(map.get_index_of(&[alias]), Some(0)); + assert_eq!(map.get_index_of(&[canonical]), Some(0)); + assert_eq!(map.output_at(0).at(0), canonical); +} + +#[test] +fn keys_and_outputs_widen_independently_without_rehashing() { + let mut map = QueryMap::new(16); + for n in 0..2048 { + map.insert(&key(n), &output(n), G::ONE).unwrap(); + } + let mut large = output(2048); + large[3] = G::NEG_ONE; + map.insert(&key(2048), &large, G::ZERO).unwrap(); + assert!(matches!(map.get_index(0).unwrap().0, QuerySlice::Bytes(_))); + assert!(matches!(map.output_at(0), QuerySlice::Packed(_))); + let mut large_key = key(2049); + large_key[4] = G::from_u64(1 << 48); + map.insert(&large_key, &output(2049), G::ONE).unwrap(); + assert!(matches!(map.get_index(0).unwrap().0, QuerySlice::Packed(_))); + for n in 0..2048 { + let index = usize::try_from(n).unwrap(); + assert_eq!(map.get_index_of(&key(n)), Some(index)); + assert_eq!(map.output_at(index).to_array::<9>(), output(n)); + } + assert_eq!(map.get_index_of(&large_key), Some(2049)); + assert_eq!(map.output_at(2048).to_array::<9>(), large); + let (stored_key, _) = map.get_index(2049).unwrap(); + assert!(stored_key.matches(&large_key)); + map.bump_multiplicity(2049).unwrap(); + assert_eq!(map.mult_at(2049), G::TWO); +} + +#[test] +fn segment_boundary_and_late_widening_preserve_earlier_segments() { + let mut store = PackedStore::new(1, true); + for i in 0..SEG_ENTRIES + 3 { + let row = [G::from_u8(u8::try_from(i % 256).unwrap())]; + let plan = store.plan(&row); + store.push(&row, plan); + } + let wide = [G::from_u64(1 << 40)]; + let plan = store.plan(&wide); + assert!(plan.transient > 0); + store.push(&wide, plan); + assert!(matches!(store.at(0), QuerySlice::Bytes(_))); + assert!(matches!(store.at(SEG_ENTRIES), QuerySlice::Fields(_))); + assert_eq!(store.at(SEG_ENTRIES - 1).at(0), G::from_u8(255)); + assert_eq!(store.at(SEG_ENTRIES + 2).at(0), G::from_u8(2)); + assert_eq!(store.at(SEG_ENTRIES + 3).at(0), wide[0]); + assert_eq!(store.retained_bytes(), SEG_ENTRIES + 4 * 8); + + let mut late = PackedStore::new(1, true); + for _ in 0..SEG_ENTRIES - 1 { + let row = [G::ONE]; + let plan = late.plan(&row); + late.push(&row, plan); + } + let plan = late.plan(&wide); + assert!(plan.transient > 0); + late.push(&wide, plan); + assert_eq!(late.retained_bytes(), SEG_ENTRIES * 8); + assert_eq!(late.at(0).at(0), G::ONE); + assert_eq!(late.at(SEG_ENTRIES - 1).at(0), wide[0]); +} + +#[test] +fn failed_widening_is_atomic_and_success_covers_temporary_storage() { + let mut reference = QueryMap::new(16); + for n in 0..4096 { + reference.insert(&key(n), &output(n), G::ONE).unwrap(); + } + let limit = reference.accounted_bytes() + (1 << 20); + let budget = ExecutionBudget::new(limit, "compact".into(), None); + let mut bounded = QueryMap::with_budget(16, Some(budget.clone())); + for n in 0..4096 { + bounded.insert(&key(n), &output(n), G::ONE).unwrap(); + } + let before = budget.used(); + let mut wide_key = key(4096); + wide_key[0] = G::NEG_ONE; + let mut wide_out = output(4096); + wide_out[0] = G::from_u16(256); + assert!(bounded.insert(&wide_key, &wide_out, G::ONE).is_err()); + assert_eq!(bounded.len(), 4096); + assert_eq!(bounded.get_index_of(&wide_key), None); + assert!(matches!(bounded.output_at(0), QuerySlice::Bytes(_))); + assert_eq!(rows(&bounded), rows(&reference)); + assert_eq!(budget.used(), before); + drop(bounded); + assert_eq!(budget.used(), 0); + + let roomy = ExecutionBudget::new(1 << 30, "wide".into(), None); + let mut map = QueryMap::with_budget(16, Some(roomy.clone())); + for n in 0..4096 { + map.insert(&key(n), &output(n), G::ONE).unwrap(); + } + map.insert(&wide_key, &wide_out, G::ONE).unwrap(); + assert_eq!(map.output_at(4096).to_array::<9>(), wide_out); + assert_eq!(roomy.used(), map.accounted_bytes()); + assert!( + roomy.peak() > roomy.used(), + "both old and replacement segments were charged" + ); + drop(map); + assert_eq!(roomy.used(), 0); +} + +#[test] +fn empty_keys_outputs_and_views_preserve_shape() { + let mut map = QueryMap::new(0); + map.finish(&[], &[], false).unwrap(); + map.finish(&[], &[], true).unwrap(); + assert_eq!(map.len(), 1); + assert_eq!(map.get_index_of(&[]), Some(0)); + assert_eq!(map.output_at(0).to_array::<0>(), []); + assert!(map.output_at(0).is_empty()); + assert_eq!(map.retained_bytes(), 0); + assert_eq!(map.mult_at(0), G::ONE); + let bytes = QuerySlice::Bytes(&[0, 255]); + let fields = [G::ZERO, G::from_u8(255)]; + assert_eq!(bytes, QuerySlice::Fields(&fields)); + assert!(bytes.matches(&fields)); + assert!(!bytes.matches(&[G::ZERO, G::from_u16(511)])); + let mut copied = [G::ONE; 2]; + bytes.copy_to_slice(&mut copied); + assert_eq!(copied, fields); + assert_eq!( + bytes.iter().rev().collect::>(), + vec![fields[1], fields[0]] + ); +} + +#[test] +#[ignore = "million-row storage/throughput comparison; run explicitly in release mode"] +fn million_byte_rows_storage_and_throughput() { + for compact in [false, true] { + let started = std::time::Instant::now(); + let mut map = QueryMap::with_storage(16, None, compact); + for n in 0..1_000_000 { + map.insert(&key(n), &output(n), G::ONE).unwrap(); + } + let insert = started.elapsed(); + let read = std::time::Instant::now(); + for n in (0..1_000_000).rev() { + let i = map.get_index_of(&key(n)).unwrap(); + assert_eq!(map.output_at(i).to_array::<9>(), output(n)); + } + eprintln!( + "[query-storage] compact={compact} rows={} payload={} accounted={} insert={insert:?} lookup={:?}", + map.len(), + map.retained_bytes(), + map.accounted_bytes(), + read.elapsed() + ); + } +} + +fn limb_key(n: u32) -> [G; 10] { + let mut row = [G::ZERO; 10]; + for (out, byte) in + row[1..9].iter_mut().zip(u64::from(n).wrapping_mul(7919).to_le_bytes()) + { + *out = G::from_u8(byte); + } + row[9] = G::from_u32(n); + row +} + +#[test] +fn columns_widen_independently_at_byte_and_u32_boundaries() { + let mut store = PackedStore::new(3, true); + let rows = [ + [G::ONE, G::ONE, G::from_u8(255)], + [G::ONE, G::ONE, G::from_u16(256)], + [G::ONE, G::from_u16(256), G::from_u32(u32::MAX)], + [G::ONE, G::from_u64(1 << 32), G::from_u32(u32::MAX)], + [G::new(G::ORDER_U64 + 7), G::NEG_ONE, G::from_u16(256)], + ]; + for (i, row) in rows.iter().enumerate() { + let plan = store.plan(row); + store.push(row, plan); + for (j, previous) in rows[..=i].iter().enumerate() { + assert_eq!(store.at(j).to_array::<3>(), *previous); + } + } + // byte + full-field + u32, rather than widening all three columns. + assert_eq!(store.retained_bytes(), rows.len() * 13); + assert!(matches!(store.at(0), QuerySlice::Packed(_))); + let mut copied = [G::ZERO; 3]; + store.at(4).copy_to_slice(&mut copied); + assert_eq!(copied, rows[4]); + assert_eq!( + store.at(4).iter().rev().collect::>(), + rows[4].into_iter().rev().collect::>() + ); +} + +#[test] +fn mixed_keys_and_implicit_pointers_match_full_width_records() { + let mut packed = QueryMap::with_memory_budget(10, None); + let mut full = QueryMap::with_storage(10, None, false); + for n in 0..65_536u32 { + let key = limb_key(n); + let output = [G::from_u32(n)]; + for map in [&mut packed, &mut full] { + map.insert(&key, &output, G::ZERO).unwrap(); + let index = usize::try_from(n).unwrap(); + assert_eq!(map.get_index_of(&key), Some(index)); + assert_eq!(map.output_at(index).to_array::<1>(), output); + map.bump_multiplicity(index).unwrap(); + } + } + assert_eq!(rows(&packed), rows(&full)); + assert_eq!(packed.retained_elems(), full.retained_elems()); + assert_eq!(packed.retained_bytes(), 65_536 * 13); + assert_eq!(full.retained_bytes(), 65_536 * 88); + assert!(packed.accounted_bytes() < full.accounted_bytes()); + assert!(matches!(packed.output_at(256), QuerySlice::Value(_))); +} + +#[test] +fn implicit_pointer_invariant_is_checked_before_mutation() { + let mut map = QueryMap::with_memory_budget(1, None); + map.insert(&[G::from_u16(256)], &[G::ZERO], G::ZERO).unwrap(); + for bad_output in [vec![], vec![G::ZERO], vec![G::ONE, G::ONE]] { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + map.insert(&[G::from_u16(257)], &bad_output, G::ONE).unwrap(); + })); + assert!(result.is_err()); + assert_eq!(map.len(), 1); + assert_eq!(map.get_index_of(&[G::from_u16(257)]), None); + assert_eq!(map.output_at(0).at(0), G::ZERO); + } + map.insert(&[G::from_u16(257)], &[G::ONE], G::ONE).unwrap(); + assert_eq!(map.output_at(1).at(0), G::ONE); +} + +#[test] +fn rejected_u32_promotion_preserves_column_layout_and_accounting() { + let mut reference = QueryMap::new(10); + for n in 0..256u32 { + reference.insert(&limb_key(n), &[G::from_u32(n)], G::ONE).unwrap(); + } + let budget = ExecutionBudget::new( + reference.accounted_bytes() + (1 << 20), + "u32-promotion".into(), + None, + ); + let mut bounded = QueryMap::with_budget(10, Some(budget.clone())); + for n in 0..256u32 { + bounded.insert(&limb_key(n), &[G::from_u32(n)], G::ONE).unwrap(); + } + let before = budget.used(); + assert!(bounded.insert(&limb_key(256), &[G::from_u16(256)], G::ONE).is_err()); + assert_eq!(rows(&bounded), rows(&reference)); + assert!(matches!(bounded.get_index(0).unwrap().0, QuerySlice::Bytes(_))); + assert_eq!(budget.used(), before); + drop(bounded); + assert_eq!(budget.used(), 0); +} + +#[test] +fn mixed_segment_boundary_preserves_finished_segment_layout() { + let mut store = PackedStore::new(2, true); + for _ in 0..SEG_ENTRIES { + let row = [G::ONE, G::from_u16(256)]; + let plan = store.plan(&row); + store.push(&row, plan); + } + let row = [G::ONE, G::from_u64(1 << 32)]; + let plan = store.plan(&row); + assert_eq!(plan.transient, 0, "new segment does not copy the full one"); + store.push(&row, plan); + assert_eq!(store.retained_bytes(), SEG_ENTRIES * 5 + 9); + assert_eq!(store.at(SEG_ENTRIES - 1).at(1), G::from_u16(256)); + assert_eq!(store.at(SEG_ENTRIES).to_array::<2>(), row); +} + +#[test] +#[ignore = "million-row mixed-key storage benchmark; run explicitly in release mode"] +fn million_mixed_memory_rows_storage_and_throughput() { + for mode in ["full", "packed", "implicit"] { + let mut map = match mode { + "full" => QueryMap::with_storage(10, None, false), + "packed" => QueryMap::new(10), + _ => QueryMap::with_memory_budget(10, None), + }; + let start = std::time::Instant::now(); + for n in 0..1_000_000u32 { + map.insert(&limb_key(n), &[G::from_u32(n)], G::ONE).unwrap(); + } + let insert = start.elapsed(); + let start = std::time::Instant::now(); + for n in (0..1_000_000u32).rev() { + let index = map.get_index_of(&limb_key(n)).unwrap(); + assert_eq!(map.output_at(index).at(0), G::from_u32(n)); + } + eprintln!( + "[mixed-storage] mode={mode} rows={} payload={} accounted={} insert={insert:?} lookup={:?}", + map.len(), + map.retained_bytes(), + map.accounted_bytes(), + start.elapsed() + ); + } +} diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index ae7e2ac89..94a3f908d 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -58,11 +58,13 @@ fn calibrate_prover_rss(analytic_peak: usize) -> usize { /// Outcome of a budget-gated prove /// ([`AiurSystem::prove_ixvm_within_budget`]). Only the case that ran a -/// STARK carries a proof; the other two report the measured peak the -/// caller decides with. +/// STARK carries a proof. Completed executions report a measured peak; +/// interrupted/rejected executions carry an error and no measurement. // One short-lived value per prove; the variant size gap is irrelevant. #[allow(clippy::large_enum_variant)] pub enum GatedProve { + /// Execution did not complete. No record peak and no proof are available. + ExecutionFailed(ExecError), /// Fit the budget; proven from the gating record. Proved { claim: Vec, proof: AiurProof, peak: usize }, /// Over budget: the record was dropped, and `parts` is the count @@ -107,19 +109,26 @@ pub struct CircuitShape { pub preprocessed_height: usize, } -/// Raw row count of a circuit under `record`, ceil-divided into `parts` -/// even shares — `parts = 1` is the record's exact heights. The byte +/// Conservative row count of a circuit under `record`, ceil-divided into +/// `parts` even shares. Sum member-function rows before dividing; circuit +/// indices are not function indices. Unlike witness generation, the estimate +/// still includes zero-multiplicity hint rows. The byte /// gadgets keep their fixed heights: they are the same size in every /// shard and are most of the peak model's floor, which dividing cannot /// shrink. -fn raw_of( - record: &QueryRecord, +fn raw_of<'a>( + toplevel: &'a Toplevel, + record: &'a QueryRecord, parts: usize, -) -> impl Fn(usize, &CircuitType) -> usize + '_ { +) -> impl Fn(usize, &CircuitType) -> usize + 'a { move |_, ct| match ct { - CircuitType::Function { idx } => { - record.function_queries[*idx].len().div_ceil(parts) - }, + CircuitType::Function { idx } => toplevel.circuits[*idx] + .members + .iter() + .fold(0usize, |rows, &member| { + rows.saturating_add(record.function_queries[member].len()) + }) + .div_ceil(parts), CircuitType::Memory { width } => { record.memory_queries.get(width).map_or(0, |m| m.len().div_ceil(parts)) }, @@ -280,7 +289,7 @@ impl AiurSystem { /// which per-fft models blur. pub fn peak_prove_bytes(&self, record: &QueryRecord) -> PeakProveBytes { self.peak_prove_bytes_by( - raw_of(record, 1), + raw_of(&self.toplevel, record, 1), crate::execute::record_retained_bytes(record), ) } @@ -371,7 +380,10 @@ impl AiurSystem { // count; stop rather than search forever. while parts < (1 << 20) { let peak = self - .peak_prove_bytes_by(raw_of(record, parts), record_bytes / parts) + .peak_prove_bytes_by( + raw_of(&self.toplevel, record, parts), + record_bytes / parts, + ) .peak; if peak <= max_bytes { break; @@ -500,6 +512,9 @@ impl AiurSystem { fun_idx, input, io_buffer, executor, None, false, ) { GatedProve::Proved { claim, proof, .. } => (claim, proof), + GatedProve::ExecutionFailed(error) => { + panic!("Aiur execution failed: {error}") + }, _ => unreachable!("an unbudgeted prove always proves"), } } @@ -544,8 +559,10 @@ impl AiurSystem { tracing_texray::examine_current(); let _g = tracing::info_span!("aiur/execute_ixvm").entered(); let (query_record, output) = - executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) - .expect("IxVM-native Aiur execution failed during prove_ixvm"); + match executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) { + Ok(result) => result, + Err(error) => return GatedProve::ExecutionFailed(error), + }; drop(_g); let peak = self.peak_prove_bytes(&query_record).peak; @@ -897,6 +914,43 @@ mod tests { with_singleton_circuits(vec![f, g, h], vec![]) } + /// Put the nested callees in one circuit, retaining the entry singleton. + /// The members have different auxiliary/lookup widths and selector offsets. + fn grouped_promotion_toplevel() -> Toplevel { + let mut toplevel = unconstrained_call_promotion_toplevel(); + toplevel.circuits.truncate(1); + toplevel.circuits.push(crate::bytecode::Circuit { + members: vec![1, 2], + layout: FunctionLayout { + input_size: 1, + selectors: 2, + auxiliaries: 2, + lookups: 2, + }, + }); + toplevel + } + + #[test] + fn grouped_peak_rows_sum_member_queries_before_dividing() { + let toplevel = grouped_promotion_toplevel(); + let mut record = QueryRecord::new(&toplevel); + for (function, count) in [1, 3, 5].into_iter().enumerate() { + for index in 0..count { + record.function_queries[function] + .insert(&[G::from_usize(index)], &[G::ONE], G::ONE) + .unwrap(); + } + } + let exact = raw_of(&toplevel, &record, 1); + assert_eq!(exact(0, &CircuitType::Function { idx: 0 }), 1); + assert_eq!(exact(1, &CircuitType::Function { idx: 1 }), 8); + let split = raw_of(&toplevel, &record, 3); + assert_eq!(split(1, &CircuitType::Function { idx: 1 }), 3); + assert_eq!(split(2, &CircuitType::Bytes1), 256); + assert_eq!(split(3, &CircuitType::Bytes2), 65536); + } + #[test] fn prove_verify_promotes_nested_unconstrained_call() { let (cp, fp) = test_parameters(); @@ -915,6 +969,137 @@ mod tests { .expect("nested constrained promotion must balance function channels"); } + #[test] + fn compact_storage_preserves_witnesses_and_lookup_traces() { + use multi_stark::lookup::LookupValues; + + fn witness( + system: &AiurSystem, + record: &QueryRecord, + io: &IOBuffer, + ) -> (Vec>, Vec>) { + system + .circuit_types() + .into_iter() + .enumerate() + .map(|(i, circuit)| { + let widths = &system.slot_widths[i]; + match circuit { + CircuitType::Function { idx } => { + system.toplevel.witness_data(idx, record, io, widths) + }, + CircuitType::Memory { width } => { + Memory::witness_data(width, record, widths) + }, + CircuitType::Bytes1 => Bytes1.witness_data(record, widths), + CircuitType::Bytes2 => Bytes2.witness_data(record, widths), + } + }) + .unzip() + } + + for toplevel in [ + call_and_memory_toplevel(), + unconstrained_call_promotion_toplevel(), + grouped_promotion_toplevel(), + xor_splits_toplevel(), + ] { + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(toplevel, cp, fp); + // Exercise byte encoding, output-only widening (255 + 1), wide + // inputs/outputs and a field wraparound. Byte gadgets remain in range. + let values = if system.toplevel.memory_sizes.is_empty() + && system.toplevel.functions.len() == 1 + { + vec![G::ZERO, G::ONE, G::from_u8(255)] + } else { + vec![G::ONE, G::from_u8(255), G::from_u64(1 << 48), G::NEG_ONE] + }; + for value in values { + let input = vec![value; system.toplevel.functions[0].layout.input_size]; + let mut compact_io = empty_io_buffer(); + let mut full_io = empty_io_buffer(); + let (compact, compact_out) = system + .toplevel + .execute_test_storage(0, input.clone(), &mut compact_io, true) + .unwrap(); + let (full, full_out) = + system.toplevel.execute_uncompressed(0, input, &mut full_io).unwrap(); + assert_eq!(compact_out, full_out); + let (compact_traces, compact_lookups) = + witness(&system, &compact, &compact_io); + let (full_traces, full_lookups) = witness(&system, &full, &full_io); + assert_eq!( + compact_traces, full_traces, + "every main-trace field, including multiplicities and padding" + ); + // LookupValues does not expose its flat buffers. Compare its public + // stage-2 construction at two challenges as well as the exact main + // traces, row-level storage differentials and proof checks. + let groups = vec![1; compact_lookups.len()]; + for challenge in [G::from_u64(1_000_003), G::from_u64(1_000_033)] { + let compact_stage2 = LookupValues::stage_2_traces( + &compact_lookups, + &groups, + challenge, + &G::from_u8(37), + G::ZERO, + ); + let full_stage2 = LookupValues::stage_2_traces( + &full_lookups, + &groups, + challenge, + &G::from_u8(37), + G::ZERO, + ); + assert_eq!(compact_stage2, full_stage2); + } + } + } + } + + #[test] + fn compact_and_full_records_both_prove_the_same_claim() { + assert_compact_full_proofs( + call_and_memory_toplevel(), + &[G::from_u8(255), G::from_u64(1 << 48)], + ); + } + + #[test] + fn grouped_compact_and_full_records_both_prove_the_same_claim() { + assert_compact_full_proofs( + grouped_promotion_toplevel(), + &[G::from_u64(1 << 48)], + ); + } + + fn assert_compact_full_proofs(toplevel: Toplevel, input: &[G]) { + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(toplevel, cp, fp); + let mut compact_io = empty_io_buffer(); + let mut full_io = empty_io_buffer(); + let (compact, compact_out) = system + .toplevel + .execute_test_storage(0, input.to_vec(), &mut compact_io, true) + .unwrap(); + let (full, full_out) = system + .toplevel + .execute_uncompressed(0, input.to_vec(), &mut full_io) + .unwrap(); + let (compact_claim, compact_proof) = + system.prove_from_execution(0, input, &compact_io, compact, &compact_out); + let (full_claim, full_proof) = + system.prove_from_execution(0, input, &full_io, full, &full_out); + assert_eq!(compact_claim, full_claim); + for proof in [&compact_proof, &full_proof] { + system.verify(&compact_claim, proof).unwrap(); + let mut bad_claim = compact_claim.clone(); + *bad_claim.last_mut().unwrap() += G::ONE; + assert!(system.verify(&bad_claim, proof).is_err()); + } + } + #[test] fn prove_verify_mul_roundtrip() { let (cp, fp) = test_parameters(); @@ -947,6 +1132,32 @@ mod tests { ); } + #[test] + fn resource_limited_execution_never_becomes_a_measurement_or_proof() { + use crate::execute::budget::ExecutionBudget; + let (cp, fp) = test_parameters(); + let system = AiurSystem::build(mul_toplevel(), cp, fp); + for exec_only in [true, false] { + let budget = ExecutionBudget::new(8 << 20, "test".into(), None); + let retained = budget.clone(); + let result = system.prove_ixvm_within_budget( + 0, + &[G::ONE, G::ONE], + &mut empty_io_buffer(), + move |t, idx, input, io| { + t.execute_with_budget(idx, input, io, Some(budget)) + }, + None, + exec_only, + ); + assert!(matches!( + result, + GatedProve::ExecutionFailed(ExecError::ResourceLimit(_)) + )); + assert_eq!(retained.used(), 0); + } + } + #[test] fn circuit_shapes_match_system() { let (cp, fp) = test_parameters(); diff --git a/crates/aiur/src/trace.rs b/crates/aiur/src/trace.rs index 66e88cf92..90110e134 100644 --- a/crates/aiur/src/trace.rs +++ b/crates/aiur/src/trace.rs @@ -20,7 +20,7 @@ use crate::{ function_channel, gadgets::{bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, - querymap::QueryRef, + querymap::{QueryMap, QuerySlice}, u8_add_channel, u8_and_channel, u8_bit_decomposition_channel, u8_less_than_channel, u8_mul_channel, u8_or_channel, u8_range_check_channel, u8_shift_left_channel, u8_shift_right_channel, u8_sub_channel, @@ -96,20 +96,18 @@ impl<'a, 'b> ColumnMutSlice<'a, 'b> { struct TraceContext<'a> { function_index: G, multiplicity: G, - inputs: &'a [G], - output: &'a [G], + inputs: QuerySlice<'a>, + output: QuerySlice<'a>, query_record: &'a QueryRecord, } -/// One row of a circuit trace: the member function it belongs to, the -/// member's selector offset within the circuit, its function index, and the -/// recorded query. -struct RowMeta<'a> { +/// Shared metadata for a circuit member. Selected rows retain only the +/// member/index pair, not decoded packed query views or repeated layouts. +struct MemberMeta<'a> { function: &'a Function, sel_offset: usize, function_index: G, - inputs: &'a [G], - result: QueryRef<'a>, + queries: &'a QueryMap, } impl Toplevel { @@ -125,22 +123,24 @@ impl Toplevel { let width = layout.width(); // Concatenate the members' queried rows, in member order. let mut rows_meta = Vec::new(); + let mut members = Vec::with_capacity(circuit.members.len()); let mut sel_offset = 0; for &member in &circuit.members { let function = &self.functions[member]; let function_index = G::from_usize(member); + let queries = &query_record.function_queries[member]; + let member_index = members.len(); rows_meta.extend( - query_record.function_queries[member] - .iter() - .filter(|(_, res)| !res.multiplicity.is_zero()) - .map(|(inputs, result)| RowMeta { - function, - sel_offset, - function_index, - inputs, - result, - }), + (0..queries.len()) + .filter(|&index| !queries.mult_at(index).is_zero()) + .map(|index| (member_index, index)), ); + members.push(MemberMeta { + function, + sel_offset, + function_index, + queries, + }); sel_offset += function.layout.selectors; } let height_no_padding = rows_meta.len(); @@ -162,7 +162,9 @@ impl Toplevel { .zip(row_writers[..height_no_padding].par_iter_mut()) .enumerate() .for_each(|(i, (row, lookups))| { - let meta = &rows_meta[i]; + let (member_index, query_index) = rows_meta[i]; + let meta = &members[member_index]; + let (inputs, result) = meta.queries.get_index(query_index).unwrap(); let index = &mut ColumnIndex { auxiliary: 0, // we skip the first lookup, which is reserved for return @@ -177,9 +179,9 @@ impl Toplevel { ); let context = TraceContext { function_index: meta.function_index, - inputs: meta.inputs, - multiplicity: meta.result.multiplicity, - output: meta.result.output, + inputs, + multiplicity: result.multiplicity, + output: result.output, query_record, }; meta.function.populate_row(index, slice, context, io_buffer); @@ -208,13 +210,13 @@ impl Function { "Argument mismatch" ); // Variable to value map - let map = &mut context.inputs.iter().map(|arg| (*arg, 1)).collect(); + let map = &mut context.inputs.iter().map(|arg| (arg, 1)).collect(); // One column per input context .inputs .iter() .enumerate() - .for_each(|(i, arg)| slice.inputs[i] = *arg); + .for_each(|(i, arg)| slice.inputs[i] = arg); // Push the multiplicity slice.push_auxiliary(index, context.multiplicity); let _ = self.body.populate_row(map, index, slice, context, io_buffer); @@ -383,13 +385,13 @@ impl Op { let queries = &context.query_record.function_queries[*function_index]; let result = queries.get(&inputs).expect("Cannot find query result"); for f in result.output.iter() { - map.push((*f, 1)); - slice.push_auxiliary(index, *f); + map.push((f, 1)); + slice.push_auxiliary(index, f); } if !op_unconstrained { let args = function_lookup_args( G::from_usize(*function_index), - &inputs, + QuerySlice::Fields(&inputs), result.output, ); slice.push_lookup(index, G::ONE, &args); @@ -408,7 +410,11 @@ impl Op { ); map.push((ptr, 1)); slice.push_auxiliary(index, ptr); - let args = Memory::lookup_args(G::from_usize(size), ptr, &values); + let args = Memory::lookup_args( + G::from_usize(size), + ptr, + QuerySlice::Fields(&values), + ); slice.push_lookup(index, G::ONE, &args); }, Op::Load(size, ptr) => { @@ -423,8 +429,8 @@ impl Op { let (values, _) = memory_queries.get_index(ptr_usize).expect("Unbound pointer"); for f in values.iter() { - map.push((*f, 1)); - slice.push_auxiliary(index, *f); + map.push((f, 1)); + slice.push_auxiliary(index, f); } let args = Memory::lookup_args(G::from_usize(*size), ptr, values); slice.push_lookup(index, G::ONE, &args); @@ -694,11 +700,11 @@ impl Op { fn function_lookup_args( function_index: G, - inputs: &[G], - output: &[G], + inputs: QuerySlice<'_>, + output: QuerySlice<'_>, ) -> Vec { let mut args = vec![function_channel(), function_index]; - args.extend(inputs); - args.extend(output); + args.extend(inputs.iter()); + args.extend(output.iter()); args } diff --git a/crates/ffi/src/aiur.rs b/crates/ffi/src/aiur.rs index 7bc3f1d19..a233f74f5 100644 --- a/crates/ffi/src/aiur.rs +++ b/crates/ffi/src/aiur.rs @@ -1,7 +1,9 @@ use multi_stark::p3_field::integers::QuotientMap; +mod admission; pub mod aggregate; mod check; +mod memory; pub mod protocol; pub mod toplevel; diff --git a/crates/ffi/src/aiur/admission.rs b/crates/ffi/src/aiur/admission.rs new file mode 100644 index 000000000..ff5143a42 --- /dev/null +++ b/crates/ffi/src/aiur/admission.rs @@ -0,0 +1,537 @@ +//! Non-preemptive admission for shard execution. A 64-thread Rayon pool does +//! not imply 64 live execution records. Reservations, cgroup headroom, recent +//! growth and a completion-driven ramp all have to permit new work. +//! +//! Active shards are never parked/cancelled while holding their records. +//! Estimates cannot bound arbitrary future allocation: keep a supervisor cap. + +use std::{ + sync::{Arc, Condvar, Mutex}, + thread::{self, JoinHandle}, + time::{Duration, Instant}, +}; + +use super::memory::{GIB, Memory, MemoryReader}; + +mod dispatch; +pub(super) use dispatch::Followups; + +#[derive(Clone, Copy)] +struct Options { + max_workers: usize, + tick: Duration, + ramp_interval: Duration, + recovery: Duration, + idle_timeout: Duration, + lookahead: Duration, +} + +impl Options { + fn new(max_workers: usize) -> Self { + Self { + max_workers: max_workers.max(1), + tick: Duration::from_millis(250), + ramp_interval: Duration::from_secs(2), + recovery: Duration::from_secs(5), + idle_timeout: Duration::from_secs(30), + lookahead: Duration::from_secs(10), + } + } +} + +struct Policy { + initial_budget: u64, + memory: Memory, + sampled: Instant, + ramped: Instant, + blocked_at: Option, + limit: usize, + completed: usize, + growth_per_second: u64, + forecast: u64, + stall_sample_bp: u64, + swap_growth: u64, + reason: &'static str, + open: bool, +} + +impl Policy { + fn new(memory: Memory, now: Instant, options: Options) -> Self { + let open = memory.budget() > 0 && memory.stall_avg10_bp <= 1000; + Self { + initial_budget: memory.budget(), + memory, + sampled: now, + ramped: now, + blocked_at: (!open).then_some(now), + limit: options.max_workers.min(8), + completed: 0, + growth_per_second: 0, + forecast: 0, + stall_sample_bp: 0, + swap_growth: 0, + reason: if memory.budget() == 0 { + "headroom" + } else if !open { + "psi-sustained" + } else { + "ready" + }, + open, + } + } + + fn sample( + &mut self, + memory: Memory, + now: Instant, + active: usize, + completed: usize, + reserved: u64, + options: Options, + ) { + let elapsed = now.saturating_duration_since(self.sampled); + let delta = memory + .rss + .saturating_add(memory.swap) + .saturating_sub(self.memory.rss.saturating_add(self.memory.swap)) + .max(self.memory.available.saturating_sub(memory.available)); + let rate = + u64::try_from(u128::from(delta) * 1_000_000 / elapsed.as_micros().max(1)) + .unwrap_or(u64::MAX); + self.growth_per_second = + rate.max(self.growth_per_second.saturating_mul(3) / 4); + self.forecast = + self.growth_per_second.saturating_mul(options.lookahead.as_secs()); + let stalls = + u128::from(memory.stall_us.saturating_sub(self.memory.stall_us)); + self.stall_sample_bp = + u64::try_from(stalls * 10_000 / elapsed.as_micros().max(1)) + .unwrap_or(u64::MAX); + self.swap_growth = memory.swap.saturating_sub(self.memory.swap); + let swapping = self.swap_growth > 8 << 20; + let psi_spike = stalls > elapsed.as_micros() / 10; + let psi_sustained = memory.stall_avg10_bp > 1000; + let needed = + memory.reserve().saturating_add(reserved).saturating_add(self.forecast); + let headroom_tight = memory.available <= needed; + let blocked = headroom_tight || swapping || psi_sustained; + // React to every >10% stall sample immediately, but do not turn a brief + // system-wide spike into a fresh five-second cooldown. Repeated 50 ms + // spikes can otherwise starve even idle, well-provisioned serial work. + // Sustained PSI, actual swap growth and insufficient headroom retain the + // full recovery delay; no permit can bypass the live reservation checks. + if blocked || psi_spike { + self.limit = self.limit.min((active / 2).max(1)); + } + if blocked { + self.blocked_at = Some(now); + } + self.open = !blocked + && !psi_spike + && self + .blocked_at + .is_none_or(|t| now.duration_since(t) >= options.recovery); + self.reason = if headroom_tight { + "headroom" + } else if swapping { + "swap-growth" + } else if psi_sustained { + "psi-sustained" + } else if psi_spike { + "psi-spike" + } else if !self.open { + "recovery" + } else { + "ready" + }; + // Do not fill the pool based on elapsed time before a single record has + // finished growing. At most one new concurrency slot per ramp interval. + if self.open + && completed > self.completed + && now.duration_since(self.ramped) >= options.ramp_interval + { + self.limit = (self.limit + 1).min(options.max_workers); + self.ramped = now; + self.completed = completed; + } + // Keep unspent completion evidence until a ramp consumes it. Otherwise + // frequent short jobs may all finish between two ramp deadlines. + self.memory = memory; + self.sampled = now; + } + + fn fits(&self, reserved: u64, next: u64) -> bool { + // Deliberately conservative: both the live charge AND all reservations + // are covered. Memory may grow after the last sample, and a released + // record may still be resident in the allocator. Never spend that RAM + // merely because its permit was returned. + self.open + && reserved.saturating_add(next) <= self.initial_budget + && self.memory.available + >= self + .memory + .reserve() + .saturating_add(reserved) + .saturating_add(next) + .saturating_add(self.forecast) + } +} + +struct State { + policy: Option, + active: usize, + completed: usize, + reserved: u64, + stopped: bool, + error: Option, + idle_since: Option, +} + +struct Shared { + state: Mutex, + changed: Condvar, + shutdown: Condvar, + options: Options, +} + +pub(super) struct Admission { + shared: Arc, + monitor: Option>, +} + +pub(super) struct Permit<'a> { + shared: &'a Shared, + bytes: u64, + completed: bool, +} + +impl Permit<'_> { + pub(super) fn complete(mut self) { + self.completed = true; + } +} + +impl Drop for Permit<'_> { + fn drop(&mut self) { + let mut state = self.shared.state.lock().unwrap(); + state.active -= 1; + state.reserved -= self.bytes; + state.completed += usize::from(self.completed); + if state.active == 0 { + state.idle_since = Some(Instant::now()); + } + self.shared.changed.notify_all(); + } +} + +impl Admission { + pub(super) fn execution_budget(&self) -> u64 { + self + .shared + .state + .lock() + .unwrap() + .policy + .as_ref() + .map_or(1 << 30, |p| p.initial_budget) + } + pub(super) fn new(max_workers: usize) -> Result { + let reader = MemoryReader::new()?; + let initial = reader.as_ref().map(MemoryReader::read).transpose()?; + Self::with_reader(Options::new(max_workers), initial, move || { + reader.as_ref().ok_or("memory reader unavailable")?.read() + }) + } + + fn with_reader( + options: Options, + initial: Option, + read: impl Fn() -> Result + Send + 'static, + ) -> Result { + let now = Instant::now(); + let shared = Arc::new(Shared { + state: Mutex::new(State { + policy: initial.map(|m| Policy::new(m, now, options)), + active: 0, + completed: 0, + reserved: 0, + stopped: false, + error: None, + idle_since: Some(now), + }), + changed: Condvar::new(), + shutdown: Condvar::new(), + options, + }); + if initial.is_some() { + log(&shared.state.lock().unwrap(), options); + } else { + eprintln!( + "[ixvm_memory] telemetry unavailable on this platform; serial admission in a {}-worker pool", + options.max_workers + ); + } + let monitor = if initial.is_some() { + let shared = Arc::clone(&shared); + Some( + thread::Builder::new() + .name("ixvm-memory".into()) + .spawn(move || { + let mut logged = now; + loop { + let mut state = shared.state.lock().unwrap(); + let deadline = + state.policy.as_ref().unwrap().sampled + options.tick; + while !state.stopped && Instant::now() < deadline { + state = shared + .shutdown + .wait_timeout( + state, + deadline.saturating_duration_since(Instant::now()), + ) + .unwrap() + .0; + } + if state.stopped { + return; + } + drop(state); + let sample = read(); + let mut state = shared.state.lock().unwrap(); + if state.stopped { + return; + } + let memory = match sample { + Ok(memory) => memory, + Err(e) => { + state.error = Some(format!( + "IxVM memory telemetry failed; stopping admission: {e}" + )); + eprintln!("[ixvm_memory] {}", state.error.as_ref().unwrap()); + state.stopped = true; + shared.changed.notify_all(); + return; + }, + }; + let now = Instant::now(); + let (active, completed, reserved) = + (state.active, state.completed, state.reserved); + let policy = state.policy.as_mut().unwrap(); + let before = (policy.limit, policy.open, policy.reason); + policy.sample(memory, now, active, completed, reserved, options); + if before != (policy.limit, policy.open, policy.reason) + || now.duration_since(logged) >= Duration::from_secs(5) + { + log(&state, options); + logged = now; + } + shared.changed.notify_all(); + } + }) + .map_err(|e| format!("start IxVM memory monitor: {e}"))?, + ) + } else { + None + }; + Ok(Self { shared, monitor }) + } + + pub(super) fn acquire(&self, estimate: usize) -> Result, String> { + let mut state = self.shared.state.lock().unwrap(); + loop { + if let Some(permit) = self.probe(&mut state, estimate)? { + return Ok(permit); + } + state = self + .shared + .changed + .wait_timeout(state, self.shared.options.tick) + .unwrap() + .0; + } + } + + /// Probe once so a dispatcher can consume completions while admission is + /// closed. Uses the same reservations, pressure policy and idle deadline as + /// the blocking API; None is not a permit or permission to bypass the gate. + fn try_acquire(&self, estimate: usize) -> Result>, String> { + self.probe(&mut self.shared.state.lock().unwrap(), estimate) + } + + fn probe( + &self, + state: &mut State, + estimate: usize, + ) -> Result>, String> { + // These ISLB/Mathlib fits are heuristics, not FLT upper bounds. Reserve + // twice the old prediction in addition to live headroom and growth. + let bytes = u64::try_from(estimate).unwrap_or(u64::MAX).saturating_mul(2); + if let Some(error) = &state.error { + return Err(error.clone()); + } + if state.stopped { + return Err("IxVM memory admission stopped".into()); + } + let fits = if let Some(p) = &state.policy { + if bytes > p.initial_budget { + let error = format!( + "IxVM shard memory reservation {bytes} bytes exceeds execution budget {} bytes; refine the shard or free memory", + p.initial_budget + ); + state.error = Some(error.clone()); + state.stopped = true; + self.shared.changed.notify_all(); + self.shared.shutdown.notify_all(); + return Err(error); + } + state.active < p.limit && p.fits(state.reserved, bytes) + } else { + state.active == 0 + }; + if fits { + let reserved = state + .reserved + .checked_add(bytes) + .ok_or("IxVM memory reservation overflow")?; + state.active += 1; + state.reserved = reserved; + state.idle_since = None; + return Ok(Some(Permit { + shared: &self.shared, + bytes, + completed: false, + })); + } + if state.active == 0 { + let since = state.idle_since.get_or_insert_with(Instant::now); + if since.elapsed() >= self.shared.options.idle_timeout { + let error = format!( + "IxVM memory admission: idle timeout with no active shards; waiting_for={} next_reservation={bytes} bytes; {}", + state.policy.as_ref().map_or("serial-admission", |p| if p.open { + "reservation-headroom" + } else { + p.reason + }), + diagnostics(state, self.shared.options) + ); + state.error = Some(error.clone()); + state.stopped = true; + self.shared.changed.notify_all(); + self.shared.shutdown.notify_all(); + return Err(error); + } + } + Ok(None) + } + + #[cfg(test)] + pub(super) fn for_test(workers: usize) -> Self { + let memory = Memory { + capacity: 1024 * GIB, + available: 1024 * GIB, + rss: 0, + swap: 0, + stall_us: 0, + stall_avg10_bp: 0, + cgroup: None, + }; + Self::with_reader(Options::new(workers), Some(memory), move || Ok(memory)) + .unwrap() + } + + /// Admission waits run on the caller, outside the target pool. Witness + /// construction itself uses nested Rayon work: blocking pool workers on + /// unadmitted shards could strand every worker behind those witnesses. + pub(super) fn map( + &self, + pool: &rayon::ThreadPool, + estimates: &[usize], + work: impl Fn(usize) -> R + Sync, + ) -> Result, String> { + if pool.current_thread_index().is_some() { + return Err( + "IxVM admission dispatcher must run outside its Rayon pool".into(), + ); + } + let results = + Mutex::new((0..estimates.len()).map(|_| None).collect::>()); + pool.in_place_scope(|scope| -> Result<(), String> { + for (index, estimate) in estimates.iter().enumerate() { + let permit = self.acquire(*estimate)?; + let (work, results) = (&work, &results); + scope.spawn(move |_| { + let result = work(index); + permit.complete(); + results.lock().unwrap()[index] = Some(result); + }); + } + Ok(()) + })?; + self.check()?; + results + .into_inner() + .unwrap() + .into_iter() + .map(|r| { + r.ok_or_else(|| "missing IxVM shard execution result".to_owned()) + }) + .collect() + } + + pub(super) fn check(&self) -> Result<(), String> { + self.shared.state.lock().unwrap().error.clone().map_or(Ok(()), Err) + } +} + +impl Drop for Admission { + fn drop(&mut self) { + self.shared.state.lock().unwrap().stopped = true; + self.shared.changed.notify_all(); + self.shared.shutdown.notify_all(); + if let Some(monitor) = self.monitor.take() { + let _ = monitor.join(); + } + } +} + +fn log(state: &State, options: Options) { + eprintln!("[ixvm_memory] {}", diagnostics(state, options)); +} + +#[allow(clippy::cast_precision_loss)] +fn diagnostics(state: &State, options: Options) -> String { + let Some(p) = &state.policy else { + return "telemetry unavailable; serial admission".into(); + }; + let gib = |v: u64| v as f64 / GIB as f64; + let cgroup = p.memory.cgroup.map_or_else( + || "none".into(), + |(used, limit)| format!("{:.1}/{:.1} GiB", gib(used), gib(limit)), + ); + let recovery = p.blocked_at.map_or(Duration::ZERO, |t| { + options.recovery.saturating_sub(p.sampled.saturating_duration_since(t)) + }); + format!( + "limit={}/{} active={} completed={} admitting={} reason={} reserved={:.1} GiB budget={:.1} GiB rss={:.1} GiB available={:.1} GiB reserve={:.1} GiB growth_forecast={:.1} GiB psi_full={:.2}% psi_avg10={:.2}% swap_growth={:.1} MiB recovery={:.1}s cgroup={cgroup}", + p.limit, + options.max_workers, + state.active, + state.completed, + p.open, + p.reason, + gib(state.reserved), + gib(p.initial_budget), + gib(p.memory.rss), + gib(p.memory.available), + gib(p.memory.reserve()), + gib(p.forecast), + p.stall_sample_bp as f64 / 100.0, + p.memory.stall_avg10_bp as f64 / 100.0, + p.swap_growth as f64 / f64::from(1 << 20), + recovery.as_secs_f64() + ) +} + +#[cfg(test)] +mod tests; diff --git a/crates/ffi/src/aiur/admission/dispatch.rs b/crates/ffi/src/aiur/admission/dispatch.rs new file mode 100644 index 000000000..dd1a86f69 --- /dev/null +++ b/crates/ffi/src/aiur/admission/dispatch.rs @@ -0,0 +1,120 @@ +//! Bounded completion-driven dispatch, outside the execution Rayon pool. + +use super::Admission; +use std::{ + collections::VecDeque, + panic::{AssertUnwindSafe, catch_unwind}, + sync::mpsc, +}; + +pub(in crate::aiur) enum Followups { + Ready(Vec), + /// Shared-budget exhaustion: stop admission until all outstanding attempts + /// have returned and released their records/permits, then retry unchanged. + AfterDrain(T), +} + +impl Admission { + /// `work` must drop its execution record before returning. Only compact + /// results cross the channel, after the permit is released. Outstanding + /// tasks AND unconsumed completions together are bounded by pool width. + /// No admission or channel wait occupies an execution-pool worker. + pub(in crate::aiur) fn dispatch( + &self, + pool: &rayon::ThreadPool, + initial: Vec, + estimate: impl Fn(&T) -> usize, + work: impl Fn(&T) -> Result + Sync, + mut complete: impl FnMut(T, R) -> Result, String>, + ) -> Result<(), String> { + if pool.current_thread_index().is_some() { + return Err( + "IxVM admission dispatcher must run outside its Rayon pool".into(), + ); + } + let width = pool.current_num_threads(); + let (tx, rx) = mpsc::sync_channel::<(T, Result)>(width); + let mut ready = VecDeque::from(initial); + let mut deferred = VecDeque::new(); + let mut in_flight = 0; + let mut next_estimate = None; + pool.in_place_scope(|scope| -> Result<(), String> { + loop { + self.check()?; + // Drain completions before probing the next reservation. A blocked + // head item must not delay observing failures, splits or released RAM. + while let Ok((task, result)) = rx.try_recv() { + in_flight -= 1; + match complete(task, result?)? { + Followups::Ready(children) => ready.extend(children), + Followups::AfterDrain(task) => deferred.push_back(task), + } + } + if in_flight == 0 && !deferred.is_empty() { + deferred.append(&mut ready); + std::mem::swap(&mut ready, &mut deferred); + next_estimate = None; + } + if in_flight == 0 && ready.is_empty() { + return self.check(); + } + if deferred.is_empty() + && in_flight < width + && let Some(next) = ready.front() + && let Some(permit) = self + .try_acquire(*next_estimate.get_or_insert_with(|| estimate(next)))? + { + let task = ready.pop_front().unwrap(); + next_estimate = None; + let (work, tx) = (&work, &tx); + in_flight += 1; + scope.spawn(move |_| { + // Under unwind builds, a panic must produce a completion error, + // not strand the dispatcher waiting for a lost message. Abort/OOM + // builds still terminate the process; neither yields partial success. + let result = catch_unwind(AssertUnwindSafe(|| work(&task))) + .unwrap_or_else(|payload| { + let message = payload + .downcast_ref::<&str>() + .copied() + .or_else(|| { + payload.downcast_ref::().map(String::as_str) + }) + .unwrap_or("non-string panic"); + Err(format!("IxVM shard worker panicked: {message}")) + }); + if result.is_ok() { + permit.complete(); + } else { + drop(permit); + } + // At most `width` outstanding messages: even if the coordinator + // returns an error, scope join cannot strand workers on a full queue. + let _ = tx.send((task, result)); + }); + continue; + } + match rx.recv_timeout(self.shared.options.tick) { + Ok((task, result)) => { + in_flight -= 1; + match complete(task, result?)? { + Followups::Ready(children) => ready.extend(children), + Followups::AfterDrain(task) => deferred.push_back(task), + } + }, + Err(mpsc::RecvTimeoutError::Timeout) => {}, + Err(mpsc::RecvTimeoutError::Disconnected) => { + return Err( + "IxVM completion channel disconnected with unfinished work" + .into(), + ); + }, + } + } + })?; + self.check() + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/ffi/src/aiur/admission/dispatch/tests.rs b/crates/ffi/src/aiur/admission/dispatch/tests.rs new file mode 100644 index 000000000..0568496ed --- /dev/null +++ b/crates/ffi/src/aiur/admission/dispatch/tests.rs @@ -0,0 +1,385 @@ +use super::*; +use crate::aiur::admission::{ + Options, + tests::{memory, quick_options}, +}; +use std::sync::{ + Mutex, + atomic::{AtomicBool, AtomicUsize, Ordering}, +}; +use std::time::Duration; + +fn pool(workers: usize) -> rayon::ThreadPool { + rayon::ThreadPoolBuilder::new().num_threads(workers).build().unwrap() +} + +struct Dropped<'a>(&'a AtomicBool); +impl Drop for Dropped<'_> { + fn drop(&mut self) { + self.0.store(true, Ordering::SeqCst); + } +} + +#[test] +fn children_run_before_an_unrelated_slow_attempt_finishes() { + let gate = Admission::for_test(2); + let pool = pool(2); + let (slow_tx, slow_rx) = mpsc::channel(); + let (child_tx, child_rx) = mpsc::channel(); + let slow_rx = Mutex::new(slow_rx); + let child_rx = Mutex::new(child_rx); + let parent_dropped = AtomicBool::new(false); + let mut finished = Vec::new(); + gate + .dispatch( + &pool, + vec![0, 1], + |_| 1024, + |&task| { + match task { + 0 => { + let _record = Dropped(&parent_dropped); + slow_rx + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(3)) + .unwrap(); + }, + 1 => { + slow_tx.send(()).unwrap(); + child_rx + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(3)) + .unwrap(); + }, + 2 => { + assert!(parent_dropped.load(Ordering::SeqCst)); + child_tx.send(()).unwrap(); + }, + _ => unreachable!(), + } + Ok(()) + }, + |task, ()| { + finished.push(task); + if task == 0 { + assert!(parent_dropped.load(Ordering::SeqCst)); + assert_eq!(gate.shared.state.lock().unwrap().active, 1); + Ok(Followups::Ready(vec![2])) + } else { + Ok(Followups::Ready(Vec::new())) + } + }, + ) + .unwrap(); + finished.sort_unstable(); + assert_eq!(finished, [0, 1, 2]); + assert_eq!(gate.shared.state.lock().unwrap().reserved, 0); +} + +#[test] +fn shared_pressure_closes_admission_until_peers_drain_then_retries_first() { + let gate = Admission::for_test(2); + let (started_tx, started_rx) = mpsc::channel(); + let (release_tx, release_rx) = mpsc::channel(); + let started_rx = Mutex::new(started_rx); + let release_rx = Mutex::new(release_rx); + let slow_dropped = AtomicBool::new(false); + let ordinary_started = AtomicBool::new(false); + let starts = Mutex::new(Vec::new()); + gate + .dispatch( + &pool(2), + vec![(0, false), (1, false), (2, false)], + |_| 1, + |&(task, retry)| { + starts.lock().unwrap().push((task, retry)); + match (task, retry) { + (0, false) => { + started_rx + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(3)) + .unwrap(); + }, + (0, true) => assert!(slow_dropped.load(Ordering::SeqCst)), + (1, _) => { + let _record = Dropped(&slow_dropped); + started_tx.send(()).unwrap(); + release_rx + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(3)) + .unwrap(); + assert!(!ordinary_started.load(Ordering::SeqCst)); + }, + (2, _) => { + ordinary_started.store(true, Ordering::SeqCst); + }, + _ => unreachable!(), + } + Ok(()) + }, + |(task, retry), ()| { + if task == 0 && !retry { + release_tx.send(()).unwrap(); + Ok(Followups::AfterDrain((task, true))) + } else { + Ok(Followups::Ready(Vec::new())) + } + }, + ) + .unwrap(); + let starts = starts.into_inner().unwrap(); + assert_eq!(starts.len(), 4); + assert!( + starts.iter().position(|&t| t == (1, false)).unwrap() + < starts.iter().position(|&t| t == (0, true)).unwrap() + ); + assert_eq!(gate.shared.state.lock().unwrap().reserved, 0); +} + +#[test] +fn recursive_queue_and_nested_rayon_work_complete_once_at_all_pool_widths() { + use rayon::prelude::*; + for workers in [1, 2, 64] { + let gate = Admission::for_test(workers); + let calls: Vec<_> = (0..127).map(|_| AtomicUsize::new(0)).collect(); + let mut results = Vec::new(); + gate + .dispatch( + &pool(workers), + vec![0usize], + |_| 1024, + |&task| { + calls[task].fetch_add(1, Ordering::SeqCst); + let (sum, index) = + rayon::join(|| (0..100).into_par_iter().sum::(), || task); + Ok(sum + index) + }, + |task, result| { + results.push((task, result)); + Ok(Followups::Ready(if task < 63 { + vec![2 * task + 1, 2 * task + 2] + } else { + vec![] + })) + }, + ) + .unwrap(); + results.sort_unstable(); + assert_eq!(results, (0..127).map(|i| (i, 4950 + i)).collect::>()); + assert!(calls.iter().all(|n| n.load(Ordering::SeqCst) == 1)); + let state = gate.shared.state.lock().unwrap(); + assert_eq!((state.active, state.reserved, state.completed), (0, 0, 127)); + } +} + +#[test] +fn worker_error_panic_and_callback_error_join_and_release_permits() { + for failure in ["error", "panic", "callback"] { + let gate = Admission::for_test(2); + let dropped = AtomicBool::new(false); + let result = gate.dispatch( + &pool(2), + vec![0], + |_| 1024, + |_| { + let _record = Dropped(&dropped); + match failure { + "error" => Err("worker failure".into()), + "panic" => panic!("test worker panic"), + _ => Ok(()), + } + }, + |_, ()| Err::, _>("callback failure".into()), + ); + assert!(result.is_err()); + assert!(dropped.load(Ordering::SeqCst)); + let state = gate.shared.state.lock().unwrap(); + assert_eq!(state.active, 0); + assert_eq!(state.reserved, 0); + assert_eq!(state.completed, usize::from(failure == "callback")); + } +} + +#[test] +fn queued_oversize_and_telemetry_failure_never_return_partial_success() { + let gate = Admission::for_test(2); + let calls = AtomicUsize::new(0); + let result = gate.dispatch( + &pool(2), + vec![0, 1], + |&task| if task == 0 { 1 } else { usize::MAX }, + |_| { + calls.fetch_add(1, Ordering::SeqCst); + Ok(()) + }, + |_, ()| Ok(Followups::Ready(Vec::new())), + ); + assert!(result.unwrap_err().contains("exceeds execution budget")); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!(gate.shared.state.lock().unwrap().active, 0); + + let gate = Admission::with_reader(quick_options(1), Some(memory()), || { + Err("lost telemetry".into()) + }) + .unwrap(); + let result = gate.dispatch( + &pool(1), + vec![0, 1], + |_| 1, + |_| { + let deadline = std::time::Instant::now() + Duration::from_secs(3); + while gate.check().is_ok() { + assert!(std::time::Instant::now() < deadline); + std::thread::yield_now(); + } + Ok(()) + }, + |_, ()| Ok(Followups::Ready(Vec::new())), + ); + assert!(result.unwrap_err().contains("telemetry failed")); + assert_eq!(gate.shared.state.lock().unwrap().reserved, 0); +} + +#[test] +fn completion_is_observed_even_when_the_next_reservation_is_blocked() { + let gate = Admission::with_reader( + Options { tick: Duration::from_secs(10), ..Options::new(2) }, + Some(memory()), + || Ok(memory()), + ) + .unwrap(); + // Close live admission while the first task is running. The coordinator must + // consume its result without waiting for a future telemetry recovery. + let calls = AtomicUsize::new(0); + let result = gate.dispatch( + &pool(2), + vec![0, 1], + |_| 100 * (1 << 30), + |_| { + calls.fetch_add(1, Ordering::SeqCst); + gate.shared.state.lock().unwrap().policy.as_mut().unwrap().open = false; + Ok(()) + }, + |_, ()| Err::, _>("observed completion".into()), + ); + assert_eq!(result.unwrap_err(), "observed completion"); + assert_eq!(calls.load(Ordering::SeqCst), 1); +} + +#[test] +fn dispatcher_rejects_its_pool_and_idle_pressure_has_a_deadline() { + let gate = Admission::for_test(1); + let pool = pool(1); + assert!( + pool + .install(|| gate.dispatch( + &pool, + vec![0], + |_| 1, + |_| Ok(()), + |_, ()| Ok(Followups::Ready(Vec::new())) + )) + .is_err() + ); + let tight = crate::aiur::memory::Memory { available: 0, ..memory() }; + let gate = + Admission::with_reader(quick_options(1), Some(tight), move || Ok(tight)) + .unwrap(); + let estimates = AtomicUsize::new(0); + assert!( + gate + .dispatch( + &pool, + vec![0], + |_| { + estimates.fetch_add(1, Ordering::SeqCst); + 0 + }, + |_| panic!("admitted without memory"), + |_, ()| Ok(Followups::Ready(Vec::new())) + ) + .unwrap_err() + .contains("idle timeout") + ); + assert_eq!( + estimates.load(Ordering::SeqCst), + 1, + "a blocked head must not rescan its ownership on every admission tick" + ); +} + +#[test] +fn early_coordinator_failure_joins_every_outstanding_worker() { + let workers = 8; + let gate = Admission::for_test(workers); + let rendezvous = (Mutex::new(0), std::sync::Condvar::new()); + let returned = AtomicUsize::new(0); + let calls = AtomicUsize::new(0); + let result = gate.dispatch( + &pool(workers), + (0..100).collect(), + |_| 1, + |_| { + calls.fetch_add(1, Ordering::SeqCst); + let mut started = rendezvous.0.lock().unwrap(); + *started += 1; + rendezvous.1.notify_all(); + let (started, _) = rendezvous + .1 + .wait_timeout_while(started, Duration::from_secs(3), |n| *n < workers) + .unwrap(); + assert_eq!( + *started, workers, + "dispatcher failed to admit the initial cohort" + ); + drop(started); + returned.fetch_add(1, Ordering::SeqCst); + Ok(()) + }, + |_, ()| Err::, _>("stop coordinator".into()), + ); + assert_eq!(result.unwrap_err(), "stop coordinator"); + assert_eq!(calls.load(Ordering::SeqCst), workers); + assert_eq!(returned.load(Ordering::SeqCst), workers); + let state = gate.shared.state.lock().unwrap(); + assert_eq!((state.active, state.reserved), (0, 0)); +} + +#[test] +fn unknown_telemetry_stays_serial_and_empty_work_is_a_noop() { + let gate = + Admission::with_reader(quick_options(64), None, || unreachable!()).unwrap(); + let pool = pool(64); + let active = AtomicUsize::new(0); + let peak = AtomicUsize::new(0); + gate + .dispatch( + &pool, + (0..32).collect(), + |_| 1024, + |_| { + let n = active.fetch_add(1, Ordering::SeqCst) + 1; + peak.fetch_max(n, Ordering::SeqCst); + std::thread::yield_now(); + active.fetch_sub(1, Ordering::SeqCst); + Ok(()) + }, + |_, ()| Ok(Followups::Ready(Vec::::new())), + ) + .unwrap(); + assert_eq!(peak.load(Ordering::SeqCst), 1); + gate + .dispatch( + &pool, + Vec::::new(), + |_| panic!("estimated empty work"), + |_| Err::<(), _>("executed empty work".into()), + |_, ()| panic!("completed empty work"), + ) + .unwrap(); + assert_eq!(gate.shared.state.lock().unwrap().completed, 32); +} diff --git a/crates/ffi/src/aiur/admission/tests.rs b/crates/ffi/src/aiur/admission/tests.rs new file mode 100644 index 000000000..9292f0a19 --- /dev/null +++ b/crates/ffi/src/aiur/admission/tests.rs @@ -0,0 +1,394 @@ +use super::*; +use std::sync::{ + atomic::{AtomicBool, AtomicUsize, Ordering}, + mpsc, +}; + +pub(super) fn memory() -> Memory { + Memory { + capacity: 420 * GIB, + available: 410 * GIB, + rss: 30 * GIB, + swap: 0, + stall_us: 0, + stall_avg10_bp: 0, + cgroup: Some((10 * GIB, 420 * GIB)), + } +} + +pub(super) fn quick_options(workers: usize) -> Options { + Options { + tick: Duration::from_millis(5), + ramp_interval: Duration::from_millis(10), + recovery: Duration::from_millis(10), + idle_timeout: Duration::from_millis(80), + ..Options::new(workers) + } +} + +#[test] +fn no_full_width_burst_or_time_only_ramp() { + let options = Options::new(64); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + assert_eq!(policy.limit, 8); + for second in 1..100 { + policy.sample( + memory(), + now + Duration::from_secs(second), + 8, + 0, + 72 * GIB, + options, + ); + } + assert_eq!(policy.limit, 8); + assert!(policy.open); +} + +#[test] +fn ramp_requires_completions_and_can_reach_the_entire_pool() { + let options = Options::new(64); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + for completed in 1..=100 { + policy.sample( + memory(), + now + Duration::from_secs(completed * 2), + 2, + usize::try_from(completed).unwrap(), + 2 * GIB, + options, + ); + } + assert_eq!(policy.limit, 64); + assert!(policy.fits(63 * GIB, GIB)); +} + +#[test] +fn live_growth_stops_admission_before_the_limit_is_reached() { + let options = Options::new(64); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + policy.sample( + Memory { available: 300 * GIB, rss: 140 * GIB, ..memory() }, + now + Duration::from_secs(1), + 8, + 0, + 72 * GIB, + options, + ); + assert!(!policy.open); + assert!(!policy.fits(72 * GIB, 9 * GIB)); + assert_eq!(policy.limit, 4); + assert_eq!(policy.forecast, 1100 * GIB); +} + +#[test] +fn reservations_and_retained_actual_memory_are_both_covered() { + let options = Options::new(64); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + assert!(!policy.fits(320 * GIB, 9 * GIB)); + // No recent growth and no outstanding permit does not mean the heap was + // returned: an allocator-retained 340 GiB must still block a new record. + policy.memory.available = 80 * GIB; + assert!(!policy.fits(0, 9 * GIB)); + policy.memory.available = 100 * GIB; + assert!(policy.fits(0, 9 * GIB)); + assert!(!policy.fits(9 * GIB, 9 * GIB)); +} + +#[test] +fn released_permits_do_not_override_pressure_or_recovery() { + let options = Options::new(64); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + let tight = Memory { available: 80 * GIB, ..memory() }; + policy.sample(tight, now + Duration::from_secs(1), 8, 0, 72 * GIB, options); + assert!(!policy.fits(0, 9 * GIB)); + // Clear growth to isolate recovery from the forecast in this test. + policy.growth_per_second = 0; + policy.sample(memory(), now + Duration::from_secs(2), 0, 8, 0, options); + assert!(!policy.open); + policy.sample(memory(), now + Duration::from_secs(7), 0, 8, 0, options); + assert!(policy.open); +} + +#[test] +fn brief_psi_spikes_do_not_starve_serial_admission() { + let options = Options::new(1); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + let mut sample = Memory { stall_avg10_bp: 250, ..memory() }; + // 50 ms of host stalls every two seconds: 20% of one 250 ms sample, + // but only 2.5% sustained pressure. Resetting a five-second cooldown on + // every spike used to starve an idle dispatcher until its 30 s deadline. + for tick in 1..=240 { + let spike = tick % 8 == 1; + if spike { + sample.stall_us += 50_000; + } + policy.sample( + sample, + now + Duration::from_millis(tick * 250), + 0, + 1, + 0, + options, + ); + assert_eq!(policy.open, !spike, "tick {tick}"); + assert_eq!(policy.fits(0, 9 * GIB), !spike, "tick {tick}"); + assert_eq!(policy.limit, 1); + } +} + +#[test] +fn sustained_psi_blocks_initial_admission_and_requires_recovery() { + let options = Options::new(64); + let now = Instant::now(); + let pressured = Memory { stall_avg10_bp: 2000, ..memory() }; + let mut policy = Policy::new(pressured, now, options); + assert!(!policy.fits(0, GIB)); + for second in 1..=60 { + policy.sample( + pressured, + now + Duration::from_secs(second), + 0, + 1, + 0, + options, + ); + assert!(!policy.open); + assert_eq!(policy.reason, "psi-sustained"); + } + // Clearing the average does not waive the cooldown, even with no workers. + policy.sample(memory(), now + Duration::from_secs(61), 0, 1, 0, options); + assert!(!policy.open); + assert_eq!(policy.reason, "recovery"); + policy.sample(memory(), now + Duration::from_secs(65), 0, 1, 0, options); + assert!(policy.fits(0, GIB)); +} + +#[test] +fn psi_spikes_still_back_off_and_cannot_waive_swap_recovery() { + let options = Options::new(64); + let now = Instant::now(); + let mut policy = Policy::new(memory(), now, options); + let spike = Memory { stall_us: 50_000, stall_avg10_bp: 250, ..memory() }; + policy.sample(spike, now + Duration::from_millis(250), 8, 0, 0, options); + assert!(!policy.open); + assert_eq!(policy.reason, "psi-spike"); + assert_eq!(policy.limit, 4); + let swapped = Memory { swap: 16 << 20, ..spike }; + policy.sample(swapped, now + Duration::from_millis(500), 0, 8, 0, options); + assert!(!policy.open); + assert_eq!(policy.reason, "swap-growth"); + policy.sample(swapped, now + Duration::from_secs(5), 0, 8, 0, options); + assert!(!policy.open); + assert_eq!(policy.reason, "recovery"); + policy.sample(swapped, now + Duration::from_millis(5500), 0, 8, 0, options); + assert!(policy.fits(0, GIB)); +} + +#[test] +fn persistent_psi_timeout_identifies_pressure_not_a_lack_of_ram() { + let pressured = Memory { stall_avg10_bp: 2000, ..memory() }; + let gate = + Admission::with_reader(quick_options(1), Some(pressured), move || { + Ok(pressured) + }) + .unwrap(); + let Err(error) = gate.acquire(1) else { + panic!("admitted during sustained pressure"); + }; + assert!(error.contains("idle timeout")); + assert!(error.contains("waiting_for=psi-sustained")); + assert!(error.contains("psi_avg10=20.00%")); + assert!(error.contains("next_reservation=2 bytes")); + assert_eq!(gate.shared.state.lock().unwrap().active, 0); +} + +#[test] +fn permits_release_on_unwind_without_claiming_a_completion() { + let gate = + Admission::with_reader(quick_options(64), Some(memory()), || Ok(memory())) + .unwrap(); + let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _permit = gate.acquire(1024).unwrap(); + panic!("test unwind"); + })); + let state = gate.shared.state.lock().unwrap(); + assert_eq!(state.active, 0); + assert_eq!(state.reserved, 0); + assert_eq!(state.completed, 0); +} + +#[test] +fn unknown_platform_is_serial_and_wakes_after_release() { + let gate = + Admission::with_reader(quick_options(64), None, || unreachable!()).unwrap(); + let first = gate.acquire(1).unwrap(); + thread::scope(|scope| { + let (tx, rx) = mpsc::channel(); + let gate = &gate; + scope.spawn(move || { + let _permit = gate.acquire(1).unwrap(); + tx.send(()).unwrap(); + }); + assert!(rx.recv_timeout(Duration::from_millis(20)).is_err()); + first.complete(); + rx.recv_timeout(Duration::from_secs(2)).unwrap(); + }); +} + +#[test] +fn oversized_reservations_fail_instead_of_bypassing_the_limit() { + let gate = + Admission::with_reader(quick_options(64), Some(memory()), || Ok(memory())) + .unwrap(); + let Err(error) = gate.acquire(usize::MAX) else { + panic!("admitted oversized shard"); + }; + assert!(error.contains("exceeds execution budget")); + assert!(gate.check().is_err()); + assert_eq!(gate.shared.state.lock().unwrap().active, 0); +} + +#[test] +fn telemetry_loss_wakes_waiters_and_is_not_success() { + let missing = Arc::new(AtomicBool::new(false)); + let input = Arc::clone(&missing); + let gate = + Admission::with_reader(quick_options(1), Some(memory()), move || { + if input.load(Ordering::SeqCst) { + Err("test telemetry loss".into()) + } else { + Ok(memory()) + } + }) + .unwrap(); + let first = gate.acquire(1).unwrap(); + thread::scope(|scope| { + let (tx, rx) = mpsc::channel(); + let gate = &gate; + scope.spawn(move || { + tx.send(gate.acquire(1).err()).unwrap(); + }); + missing.store(true, Ordering::SeqCst); + assert!( + rx.recv_timeout(Duration::from_secs(2)) + .unwrap() + .unwrap() + .contains("telemetry failed") + ); + first.complete(); + }); + assert!(gate.check().is_err()); +} + +#[test] +fn persistent_idle_pressure_returns_a_bounded_resource_error() { + let tight = Memory { available: 90 * GIB, ..memory() }; + let gate = + Admission::with_reader(quick_options(64), Some(memory()), move || { + Ok(tight) + }) + .unwrap(); + let first = gate.acquire(5 * usize::try_from(GIB).unwrap()).unwrap(); + // Wait for an actual pressure sample, not a scheduling-sensitive sleep. + let deadline = Instant::now() + Duration::from_secs(2); + while gate.shared.state.lock().unwrap().policy.as_ref().unwrap().open { + assert!(Instant::now() < deadline); + thread::yield_now(); + } + first.complete(); + let Err(error) = gate.acquire(5 * usize::try_from(GIB).unwrap()) else { + panic!("admitted under pressure"); + }; + assert!(error.contains("idle timeout")); + assert!(error.contains("waiting_for=headroom")); + assert!(error.contains("next_reservation=")); +} + +#[test] +fn all_jobs_execute_once_while_admission_caps_active_records() { + let gate = + Admission::with_reader(Options::new(64), Some(memory()), || Ok(memory())) + .unwrap(); + let active = AtomicUsize::new(0); + let peak = AtomicUsize::new(0); + let calls: Vec<_> = (0..256).map(|_| AtomicUsize::new(0)).collect(); + let pool = rayon::ThreadPoolBuilder::new().num_threads(64).build().unwrap(); + let results = gate + .map(&pool, &vec![1024; calls.len()], |index| { + let call = &calls[index]; + let live = active.fetch_add(1, Ordering::SeqCst) + 1; + peak.fetch_max(live, Ordering::SeqCst); + call.fetch_add(1, Ordering::SeqCst); + thread::sleep(Duration::from_millis(1)); + active.fetch_sub(1, Ordering::SeqCst); + index + }) + .unwrap(); + assert_eq!(results, (0..calls.len()).collect::>()); + assert!(peak.load(Ordering::SeqCst) <= 8); + assert!(calls.iter().all(|c| c.load(Ordering::SeqCst) == 1)); + let state = gate.shared.state.lock().unwrap(); + assert_eq!(state.completed, 256); + assert_eq!(state.reserved, 0); +} + +#[test] +fn nested_rayon_work_runs_with_one_worker_and_with_admission_waiters() { + use rayon::prelude::*; + for workers in [1, 2, 64] { + let gate = + Admission::with_reader(Options::new(workers), Some(memory()), || { + Ok(memory()) + }) + .unwrap(); + let pool = + rayon::ThreadPoolBuilder::new().num_threads(workers).build().unwrap(); + let results = gate + .map(&pool, &[1024; 128], |index| { + let (a, b) = + rayon::join(|| (0..1024).into_par_iter().sum::(), || index); + a + b + }) + .unwrap(); + assert_eq!( + results, + (0..128).map(|i| 1023 * 1024 / 2 + i).collect::>() + ); + } +} + +#[test] +fn dispatcher_rejects_blocking_inside_its_own_pool() { + let gate = + Admission::with_reader(Options::new(1), Some(memory()), || Ok(memory())) + .unwrap(); + let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap(); + assert!(pool.install(|| gate.map(&pool, &[1024; 3], |_| ())).is_err()); +} + +#[test] +fn dispatch_stops_on_admission_failure_without_partial_success() { + let gate = + Admission::with_reader(Options::new(2), Some(memory()), || Ok(memory())) + .unwrap(); + let pool = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap(); + let calls = [AtomicUsize::new(0), AtomicUsize::new(0), AtomicUsize::new(0)]; + assert!( + gate + .map(&pool, &[1024, usize::MAX, 1024], |i| { + calls[i].fetch_add(1, Ordering::SeqCst); + }) + .is_err() + ); + assert_eq!(calls[0].load(Ordering::SeqCst), 1); + assert_eq!(calls[1].load(Ordering::SeqCst), 0); + assert_eq!(calls[2].load(Ordering::SeqCst), 0); + assert_eq!(gate.shared.state.lock().unwrap().active, 0); +} diff --git a/crates/ffi/src/aiur/aggregate.rs b/crates/ffi/src/aiur/aggregate.rs index fc76e93cc..434032b5c 100644 --- a/crates/ffi/src/aiur/aggregate.rs +++ b/crates/ffi/src/aiur/aggregate.rs @@ -1402,6 +1402,9 @@ fn prove_aggregate( false, ) { GatedProve::Proved { claim, proof, peak } => (claim, proof, peak), + GatedProve::ExecutionFailed(error) => { + return Err(format!("aggregate execution failed: {error}")); + }, GatedProve::Split { .. } | GatedProve::Measured { .. } => { return Err("unbudgeted aggregate prove did not produce a proof".into()); }, diff --git a/crates/ffi/src/aiur/check.rs b/crates/ffi/src/aiur/check.rs index 3e1c182d2..84aff95dc 100644 --- a/crates/ffi/src/aiur/check.rs +++ b/crates/ffi/src/aiur/check.rs @@ -1,7 +1,9 @@ -//! Native startup for a whole-partition `ix check`. Only small result counts +//! Native startup for whole-partition or selected-shard `ix check`. Small counts //! cross the FFI: the mmap, manifest, ownership lists and audit stay in Rust. //! The kernel/witness executor is shared with the existing Lean wave driver. +mod refine; + use std::{fs, path::Path, sync::Arc, time::Instant}; use aiur::{bytecode::Toplevel, synthesis::AiurSystem}; @@ -9,16 +11,18 @@ use ix_common::address::Address; use ix_kernel::shard::ShardManifest; use ixon::{ConstantInfo, Env}; use lean_ffi::object::{ - LeanBorrowed, LeanExcept, LeanIOResult, LeanNat, LeanOwned, LeanString, + LeanBorrowed, LeanExcept, LeanIOResult, LeanNat, LeanOption, LeanOwned, + LeanRef, LeanString, }; use rayon::prelude::*; use rustc_hash::FxHashMap; use serde_json::{Value, json}; use super::{ + admission::Admission, lean_unbox_nat_as_usize, protocol::{ - ShardCheckResult, check_shard_batch, decode_commitment_parameters, + ShardCheckResult, ShardExecutor, decode_commitment_parameters, decode_fri_parameters, }, toplevel::decode_toplevel, @@ -139,6 +143,61 @@ struct RunConfig<'a> { revision: &'a str, command: &'a str, budget_source: &'a str, + selection: Option<&'a [usize]>, +} + +/// Startup hashes/parses immutable input, not execution records. Keep its +/// modest default independent of --jobs and RAYON_NUM_THREADS, which users +/// often set to one to bound the much heavier witness-execution phase. +fn setup_pool_size( + setting: Option<&str>, + available: usize, +) -> Result { + match setting { + None => Ok(available.clamp(1, 8)), + Some(value) => { + value.parse::().ok().filter(|&n| n > 0).ok_or_else(|| { + "IX_AIUR_SETUP_THREADS must be a positive thread count".to_string() + }) + }, + } +} + +fn prepare_with_pool( + env: &Env, + manifest: &ShardManifest, + threads: usize, +) -> Result>, String> { + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(threads) + .thread_name(|i| format!("ixvm-setup-{i}")) + .build() + .map_err(|e| format!("setup rayon pool: {e}"))?; + // This pool is dropped before execution starts. Ownership order and the + // first validation error still come from prepare_owned's indexed collect. + pool.install(|| prepare_owned(env, manifest)) +} + +/// Selection affects execution only, never global validation. Normalize at +/// this boundary as well as in the CLI: direct FFI callers must not duplicate +/// work, truncate an invalid id, or turn an empty selection into full coverage. +fn select_shards( + count: usize, + selection: Option<&[usize]>, +) -> Result, String> { + let Some(selection) = selection else { + return Ok((0..count).collect()); + }; + if selection.is_empty() { + return Err("--shards: empty selection".into()); + } + if let Some(id) = selection.iter().find(|&&id| id >= count) { + return Err(format!("--shards: shard {id} out of range ({count} shards)")); + } + let mut selected = selection.to_vec(); + selected.sort_unstable(); + selected.dedup(); + Ok(selected) } struct CheckSummary { @@ -154,13 +213,22 @@ fn audit_report( manifest: &ShardManifest, manifest_bytes: &[u8], owned: &[Vec
], - results: &[ShardCheckResult], + results: &[Option], ) -> Value { let mut leaves = Vec::new(); let mut failures = Vec::new(); for (id, ((shard, owned), result)) in manifest.shards.iter().zip(owned).zip(results).enumerate() { + let Some(result) = result else { + // Do not construct claims for thousands of untouched leaves, or imply + // that global coverage validation typechecked their declarations. + leaves.push(json!({ + "id": id, "blocks": shard.blocks.len(), "consts": owned.len(), + "claim": null, "predicted_peak_bytes": null, "status": "unchanged", + })); + continue; + }; // Usually already computed by the witness builder. Empty/failed witness // builds retain the same nullable claim field as the old audit path. let claim = result.claim.clone().or_else(|| { @@ -195,7 +263,8 @@ fn audit_report( "source": { "path": config.manifest, "bytes": manifest_bytes.len(), "blake3": blake3::hash(manifest_bytes).to_hex().to_string(), "shards": manifest.shards.len() }, "out": null, "budget_bytes": 0, "budget_source": config.budget_source, - "jobs": config.jobs, "selected": manifest.shards.len(), "executed": manifest.shards.len(), + "jobs": config.jobs, "selected": results.iter().flatten().count(), + "executed": results.iter().flatten().count(), "waves": 0, "consolidation_shards": null, "leaves": leaves, "failures": failures, }) } @@ -207,18 +276,26 @@ fn run_partition( config: &RunConfig<'_>, ) -> Result { let started = Instant::now(); + let setup_setting = match std::env::var("IX_AIUR_SETUP_THREADS") { + Ok(value) => Some(value), + Err(std::env::VarError::NotPresent) => None, + Err(error) => return Err(format!("IX_AIUR_SETUP_THREADS: {error}")), + }; + let available = std::thread::available_parallelism().map_or(1, usize::from); + let setup_threads = setup_pool_size(setup_setting.as_deref(), available)?; eprintln!("[ixvm_setup] loading manifest and metadata-light mmap"); let manifest_bytes = fs::read(config.manifest) .map_err(|e| format!("read {}: {e}", config.manifest.display()))?; let manifest = ShardManifest::from_bytes(&manifest_bytes) .map_err(|e| format!("manifest parse failed: {e}"))?; + let selected = select_shards(manifest.shards.len(), config.selection)?; let loaded = load_env(config.ixe, !config.report.is_empty())?; let loaded_at = Instant::now(); eprintln!( - "[ixvm_setup] loaded in {:.3}s; validating coverage and assigning ownership in Rust", + "[ixvm_setup] loaded in {:.3}s; validating coverage and assigning ownership in Rust ({setup_threads} setup threads)", (loaded_at - started).as_secs_f64() ); - let owned = prepare_owned(&loaded.env, &manifest)?; + let owned = prepare_with_pool(&loaded.env, &manifest, setup_threads)?; eprintln!( "[shards] OK: partition covers all {} consts, disjoint ({} shards)", loaded.env.consts.len(), @@ -230,38 +307,56 @@ fn run_partition( started.elapsed().as_secs_f64() ); eprintln!( - "Typechecking {} shard(s) in one rayon batch, {} thread(s) (0 = all)", - owned.len(), + "Typechecking {} selected source shard(s) of {} with completion-driven refinement, {} thread(s) (0 = all)", + selected.len(), + manifest.shards.len(), config.jobs ); let execution_start = Instant::now(); + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(config.jobs) + .build() + .map_err(|e| format!("execution rayon pool: {e}"))?; // Keep circuit/peak-model construction in the execution measurement, // matching the legacy shardCheckBatchWithEnv timing boundary. let system = build_system(); - // The caller installed the requested pool for both preparation and checking. - let results = check_shard_batch( + let gate = Admission::new(pool.current_num_threads())?; + let executor = ShardExecutor::new( toplevel, fun_idx, &loaded.env, - &owned, config.use_bytecode, - 0, &system, 0, - true, + gate.execution_budget(), + )?; + // Keep the admission dispatcher outside the execution pool. Its width is + // still exactly --jobs (0 = Rayon's default), regardless of setup width. + let runs = refine::run( + &loaded.env, + &manifest, + &owned, + Some(&selected), + &gate, + &pool, + |owned| executor.reservation(owned), + |owned, label| Ok(executor.check(owned, label)), )?; + let results = &runs.results; let elapsed_ms = usize::try_from(execution_start.elapsed().as_millis()) .unwrap_or(usize::MAX); - let failures = results.iter().filter(|r| !r.error.is_empty()).count(); + let failures = + results.iter().flatten().filter(|r| !r.error.is_empty()).count(); if !config.report.is_empty() { - let report = audit_report( + let mut report = audit_report( config, &loaded, &manifest, &manifest_bytes, &owned, - &results, + results, ); + refine::extend_report(&mut report, &runs); let mut bytes = serde_json::to_vec_pretty(&report) .map_err(|e| format!("audit JSON: {e}"))?; bytes.push(b'\n'); @@ -270,20 +365,28 @@ fn run_partition( eprintln!("[split-audit] report → {}", config.report); } if failures == 0 { - eprintln!("All {} shard(s) passed", owned.len()); + eprintln!( + "All {} selected source shard(s) passed via {} executed final part(s) ({} in manifest)", + selected.len(), + runs.parts.iter().map(Vec::len).sum::(), + manifest.shards.len() + ); } else { - eprintln!("{failures} of {} shard(s) FAILED", owned.len()); + eprintln!( + "{failures} of {} selected source shard(s) FAILED", + selected.len() + ); } Ok(CheckSummary { - constants: loaded.env.consts.len(), - shards: owned.len(), + constants: selected.iter().map(|&id| owned[id].len()).sum(), + shards: selected.len(), failures, elapsed_ms, }) } -/// Full-partition, no-refinement execution. Advanced split/selection/proof-cache -/// paths keep the existing driver until their orchestration is ported too. +/// Full or selected-partition execution with early resource-limit refinement. +/// Destination prover budgets and proof-cache paths retain the existing driver. #[unsafe(no_mangle)] extern "C" fn rs_aiur_check_partition( toplevel_obj: LeanAiurToplevel>, @@ -298,8 +401,24 @@ extern "C" fn rs_aiur_check_partition( revision: LeanString>, command: LeanString>, budget_source: LeanString>, + selection: LeanOption>, ) -> LeanIOResult { let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let selection = selection + .to_option() + .map(|ids| { + ids + .as_array() + .iter() + .map(|id| { + if !id.is_scalar() { + return Err("--shards: shard id too large".to_owned()); + } + Ok(id.unbox_usize()) + }) + .collect::, String>>() + }) + .transpose()?; let toplevel = decode_toplevel(&toplevel_obj); let system_toplevel = decode_toplevel(&toplevel_obj); let commitment = decode_commitment_parameters(&commitment); @@ -313,25 +432,15 @@ extern "C" fn rs_aiur_check_partition( revision: revision.as_str(), command: command.as_str(), budget_source: budget_source.as_str(), + selection: selection.as_deref(), }; let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let run = || { - run_partition( - &toplevel, - fun_idx, - || AiurSystem::build(system_toplevel, commitment, fri), - &config, - ) - }; - if config.jobs == 0 { - run() - } else { - let pool = rayon::ThreadPoolBuilder::new() - .num_threads(config.jobs) - .build() - .map_err(|e| format!("rayon pool: {e}"))?; - pool.install(run) - } + run_partition( + &toplevel, + fun_idx, + || AiurSystem::build(system_toplevel, commitment, fri), + &config, + ) })); let result = match result { Ok(Ok(summary)) => { diff --git a/crates/ffi/src/aiur/check/refine.rs b/crates/ffi/src/aiur/check/refine.rs new file mode 100644 index 000000000..4a6c7b195 --- /dev/null +++ b/crates/ffi/src/aiur/check/refine.rs @@ -0,0 +1,275 @@ +//! Early execution-limit retries for the native partition path. Split only +//! between blocks, never inside a mutual block. An aborted parent is NOT a +//! measured/proven claim: success requires every final child's execution. + +use super::super::admission::Followups; +use super::*; +use rustc_hash::FxHashSet; + +pub(super) struct Part { + pub label: String, + pub blocks: Vec
, + pub owned: Vec
, + pub result: ShardCheckResult, +} + +struct Pending { + origin: usize, + label: String, + blocks: Vec
, + owned: Vec
, + pressure_retries: usize, + generation: usize, +} + +pub(super) struct Runs { + /// Indexed by original manifest id; None means unselected, not success. + pub results: Vec>, + pub parts: Vec>, + pub attempts: usize, + pub max_generation: usize, +} + +fn split(env: &Env, pending: Pending) -> Result<[Pending; 2], String> { + let Pending { origin, label, mut blocks, owned, generation, .. } = pending; + let right = blocks.split_off(blocks.len().div_ceil(2)); + if blocks.is_empty() || right.is_empty() { + return Err( + "execution refinement must strictly reduce a non-singleton block set" + .into(), + ); + } + let left_set: FxHashSet<_> = blocks.iter().collect(); + let right_set: FxHashSet<_> = right.iter().collect(); + let mut left_owned = Vec::new(); + let mut right_owned = Vec::new(); + for addr in owned { + let lc = env.consts.get(&addr).ok_or("refinement constant missing")?; + let constant = lc.get()?; + let block = match &constant.info { + ConstantInfo::IPrj(p) => &p.block, + ConstantInfo::CPrj(p) => &p.block, + ConstantInfo::RPrj(p) => &p.block, + ConstantInfo::DPrj(p) => &p.block, + _ => &addr, + }; + if left_set.contains(block) { + left_owned.push(addr.clone()); + } else if right_set.contains(block) { + right_owned.push(addr.clone()); + } else { + return Err(format!("refinement lost ownership of {}", addr.hex())); + } + } + Ok([ + Pending { + origin, + label: format!("{label}.0"), + blocks, + owned: left_owned, + pressure_retries: 0, + generation: generation + 1, + }, + Pending { + origin, + label: format!("{label}.1"), + blocks: right, + owned: right_owned, + pressure_retries: 0, + generation: generation + 1, + }, + ]) +} + +pub(super) fn run( + env: &Env, + manifest: &ShardManifest, + owned: &[Vec
], + selection: Option<&[usize]>, + gate: &Admission, + pool: &rayon::ThreadPool, + estimate: impl Fn(&[Address]) -> usize, + execute: impl Fn(&[Address], &str) -> Result + Sync, +) -> Result { + if manifest.shards.len() != owned.len() { + return Err("execution refinement ownership count mismatch".into()); + } + let selected = select_shards(manifest.shards.len(), selection)?; + let initial: Vec<_> = selected + .iter() + .map(|&origin| Pending { + origin, + label: origin.to_string(), + blocks: manifest.shards[origin].blocks.clone(), + owned: owned[origin].clone(), + pressure_retries: 0, + generation: 0, + }) + .collect(); + let mut originals = vec![None; manifest.shards.len()]; + let mut parts: Vec> = + (0..manifest.shards.len()).map(|_| Vec::new()).collect(); + let mut attempts = 0; + let mut max_generation = 0; + let mut outstanding = vec![0usize; manifest.shards.len()]; + for &id in &selected { + outstanding[id] = 1; + } + let mut settled = 0; + let started = Instant::now(); + eprintln!( + "[ixvm_refine] completion-driven queue: {} source shard(s)", + selected.len() + ); + let work = |pending: &Pending| { + eprintln!( + "[ixvm_check] shard {} started ({} consts); attempt={} generation={}", + pending.label, + pending.owned.len(), + pending.pressure_retries + 1, + pending.generation + ); + execute(&pending.owned, &pending.label) + }; + let complete = |mut pending: Pending, result: ShardCheckResult| { + attempts += 1; + max_generation = max_generation.max(pending.generation); + if result.resource_status > 2 + || (result.resource_status != 0 + && (result.error.is_empty() || result.peak_bytes != 0)) + { + return Err("invalid resource-limited execution outcome".into()); + } + if pending.generation == 0 { + originals[pending.origin] = Some(result.clone()); + } + if result.resource_status == 2 && pending.pressure_retries < 2 { + eprintln!( + "[ixvm_refine] shard {}: shared record budget exhausted; defer attempt {} until active records drain", + pending.label, + pending.pressure_retries + 2 + ); + pending.pressure_retries += 1; + pending.generation += 1; + Ok(Followups::AfterDrain(pending)) + } else if result.resource_status == 1 && pending.blocks.len() > 1 { + eprintln!( + "[ixvm_refine] shard {}: execution memory limit; split {} blocks into two", + pending.label, + pending.blocks.len() + ); + outstanding[pending.origin] += 1; + Ok(Followups::Ready(split(env, pending)?.into())) + } else { + outstanding[pending.origin] = outstanding[pending.origin] + .checked_sub(1) + .ok_or("execution refinement settled a claim twice")?; + if outstanding[pending.origin] == 0 { + settled += 1; + } + eprintln!( + "[ixvm_check] {settled}/{} shards settled, {attempts} attempts, {:.1}s: shard {} {}", + selected.len(), + started.elapsed().as_secs_f64(), + pending.label, + if result.error.is_empty() { "ok" } else { &result.error } + ); + parts[pending.origin].push(Part { + label: pending.label, + blocks: pending.blocks, + owned: pending.owned, + result, + }); + Ok(Followups::Ready(Vec::new())) + } + }; + gate.dispatch( + pool, + initial, + |pending| estimate(&pending.owned), + work, + complete, + )?; + if settled != selected.len() || outstanding.iter().any(|&n| n != 0) { + return Err("execution refinement left work unsettled".into()); + } + // Completion order is nondeterministic; report tree labels/ownership in + // deterministic order, never arrival order or a compacted manifest index. + for origin_parts in &mut parts { + origin_parts.sort_unstable_by(|a, b| a.label.cmp(&b.label)); + } + let results = originals + .into_iter() + .zip(&parts) + .enumerate() + .map(|(id, (original, settled))| { + if selected.binary_search(&id).is_err() { + if original.is_some() || !settled.is_empty() { + return Err("execution refinement ran an unselected shard"); + } + return Ok(None); + } + let mut result = original.ok_or("missing original shard result")?; + if settled.is_empty() { + return Err("execution refinement left a shard unchecked"); + } + let failures: Vec<_> = settled + .iter() + .filter(|p| !p.result.error.is_empty()) + .map(|p| { + format!( + "shard {}: {}{}", + p.label, + p.result.error, + if p.blocks.len() <= 1 && p.result.resource_status == 1 { + "; single block cannot be split" + } else { + "" + } + ) + }) + .collect(); + result.error = failures.join("; "); + // A retried original that finally passed has a real original record. + // A split original has none: never fabricate its peak from child peaks. + if settled.len() == 1 { + result.peak_bytes = settled[0].result.peak_bytes; + result.resource_status = settled[0].result.resource_status; + } + Ok(Some(result)) + }) + .collect::, &str>>() + .map_err(str::to_owned)?; + Ok(Runs { results, parts, attempts, max_generation }) +} + +pub(super) fn extend_report(report: &mut Value, runs: &Runs) { + report["executed"] = json!(runs.attempts); + report["scheduler"] = json!("completion-driven"); + // Keep the legacy key, but do not misrepresent a lineage depth as a barrier. + report["waves"] = Value::Null; + report["max_generation"] = json!(runs.max_generation); + for (id, parts) in runs.parts.iter().enumerate() { + let Some(result) = &runs.results[id] else { continue }; + if parts.len() == 1 && parts[0].result.resource_status == 0 { + continue; + } + let leaf = &mut report["leaves"][id]; + leaf["resource_status"] = json!(result.resource_status); + if parts.len() > 1 { + leaf["status"] = + json!(if result.error.is_empty() { "refined" } else { "failed" }); + leaf["predicted_peak_bytes"] = Value::Null; + } + leaf["parts"] = json!(parts.iter().map(|p| json!({ + "label": p.label, "blocks": p.blocks.iter().map(Address::hex).collect::>(), + "consts": p.owned.len(), "claim": p.result.claim.as_ref().map(Address::hex), + "status": if p.result.error.is_empty() { "measured" } else { "failed" }, + "reason": p.result.error, "resource_status": p.result.resource_status, + "predicted_peak_bytes": if p.result.resource_status == 0 { Some(p.result.peak_bytes) } else { None }, + })).collect::>()); + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/ffi/src/aiur/check/refine/tests.rs b/crates/ffi/src/aiur/check/refine/tests.rs new file mode 100644 index 000000000..395efcb71 --- /dev/null +++ b/crates/ffi/src/aiur/check/refine/tests.rs @@ -0,0 +1,373 @@ +use super::super::tests::{axiom, manifest, store}; +use super::*; +use std::sync::Mutex; + +// Keep the existing outcome fixtures, now driven one attempt at a time by +// the real completion dispatcher. Parallel scheduling is exercised below. +fn run( + env: &Env, + manifest: &ShardManifest, + owned: &[Vec
], + selection: Option<&[usize]>, + execute: impl FnMut( + &[Vec
], + &[String], + ) -> Result, String> + + Send, +) -> Result { + let gate = Admission::for_test(1); + let pool = rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap(); + let execute = Mutex::new(execute); + super::run( + env, + manifest, + owned, + selection, + &gate, + &pool, + |_| 1024, + |owned, label| { + let mut results = + execute.lock().unwrap()(&[owned.to_vec()], &[label.to_owned()])?; + if results.len() != 1 { + return Err("missing attempt result".into()); + } + Ok(results.remove(0)) + }, + ) +} + +fn outcome(status: usize) -> ShardCheckResult { + ShardCheckResult { + error: if status == 0 { String::new() } else { "resource limit".into() }, + peak_bytes: if status == 0 { 42 } else { 0 }, + suggested_parts: if status == 0 { 1 } else { 2 }, + resource_status: status, + claim: None, + } +} + +#[test] +fn recursive_retry_checks_all_final_parts_and_keeps_mutual_projections_together() + { + let env = Env::new(); + let a = axiom(&env, 0); + let b = axiom(&env, 1); + let c = axiom(&env, 2); + let projection = + store(&env, &ixon::constant::defn_proj_constant(0, a.clone())); + let m = manifest(vec![vec![a.clone(), b.clone(), c.clone()]]); + let owned = prepare_owned(&env, &m).unwrap(); + let mut passed = Vec::new(); + let runs = run(&env, &m, &owned, None, |batch, _| { + Ok( + batch + .iter() + .map(|p| { + assert_eq!(p.contains(&a), p.contains(&projection)); + if p.contains(&b) && p.contains(&c) + || p.contains(&a) && p.contains(&b) + { + outcome(1) + } else { + passed.extend(p.clone()); + outcome(0) + } + }) + .collect(), + ) + }) + .unwrap(); + passed.sort_unstable(); + assert_eq!(passed, owned[0]); + assert_eq!(runs.parts[0].len(), 3); + assert_eq!(runs.attempts, 5); + assert!(runs.results[0].as_ref().unwrap().error.is_empty()); + assert_eq!( + runs.results[0].as_ref().unwrap().peak_bytes, + 0, + "aborted parent has no measured peak" + ); +} + +#[test] +fn single_block_limit_is_a_failure_not_an_infinite_retry_or_success() { + let env = Env::new(); + let a = axiom(&env, 0); + let m = manifest(vec![vec![a]]); + let owned = prepare_owned(&env, &m).unwrap(); + let runs = run(&env, &m, &owned, None, |batch, _| { + Ok(batch.iter().map(|_| outcome(1)).collect()) + }) + .unwrap(); + assert_eq!(runs.attempts, 1); + assert!( + runs.results[0] + .as_ref() + .unwrap() + .error + .contains("single block cannot be split") + ); +} + +#[test] +fn aggregate_limit_retries_without_changing_claim_and_is_bounded() { + let env = Env::new(); + let a = axiom(&env, 0); + let m = manifest(vec![vec![a]]); + let owned = prepare_owned(&env, &m).unwrap(); + let mut wave = 0; + let runs = run(&env, &m, &owned, None, |batch, labels| { + assert_eq!(batch, owned); + assert_eq!(labels, &["0"]); + wave += 1; + Ok(vec![outcome(if wave == 1 { 2 } else { 0 })]) + }) + .unwrap(); + assert_eq!(runs.attempts, 2); + assert!(runs.results[0].as_ref().unwrap().error.is_empty()); + assert_eq!(runs.results[0].as_ref().unwrap().peak_bytes, 42); + let limited = + run(&env, &m, &owned, None, |_, _| Ok(vec![outcome(2)])).unwrap(); + assert_eq!(limited.attempts, 3); + assert!(!limited.results[0].as_ref().unwrap().error.is_empty()); +} + +#[test] +fn semantic_failures_are_not_retried_and_missing_results_are_rejected() { + let env = Env::new(); + let m = manifest(vec![vec![axiom(&env, 0), axiom(&env, 1)]]); + let owned = prepare_owned(&env, &m).unwrap(); + let runs = run(&env, &m, &owned, None, |_, _| { + let mut failed = outcome(0); + failed.error = "ill typed".into(); + Ok(vec![failed]) + }) + .unwrap(); + assert_eq!(runs.attempts, 1); + assert!(runs.results[0].as_ref().unwrap().error.contains("ill typed")); + assert!(run(&env, &m, &owned, None, |_, _| Ok(Vec::new())).is_err()); +} + +#[test] +fn reports_do_not_claim_an_aborted_parent_was_measured() { + let env = Env::new(); + let m = manifest(vec![vec![axiom(&env, 0), axiom(&env, 1)]]); + let owned = prepare_owned(&env, &m).unwrap(); + let runs = run(&env, &m, &owned, None, |batch, _| { + Ok(batch.iter().map(|p| outcome(usize::from(p.len() > 1))).collect()) + }) + .unwrap(); + let mut report = + json!({"leaves": [{"status": "measured", "predicted_peak_bytes": 0}]}); + extend_report(&mut report, &runs); + assert_eq!(report["leaves"][0]["status"], "refined"); + assert!(report["leaves"][0]["predicted_peak_bytes"].is_null()); + assert_eq!(report["leaves"][0]["parts"].as_array().unwrap().len(), 2); + assert_eq!(report["executed"], 3); +} + +#[test] +fn selected_refinement_preserves_original_ids_and_never_executes_skipped_leaves() + { + let env = Env::new(); + let skipped_a = axiom(&env, 0); + let selected_a = axiom(&env, 1); + let skipped_b = axiom(&env, 2); + let selected_b = axiom(&env, 3); + let selected_c = axiom(&env, 4); + let m = manifest(vec![ + vec![skipped_a.clone()], + vec![selected_a], + vec![skipped_b.clone()], + vec![selected_b, selected_c], + ]); + let owned = prepare_owned(&env, &m).unwrap(); + let mut waves = Vec::new(); + let runs = run(&env, &m, &owned, Some(&[3, 1, 3]), |batch, labels| { + waves.push(labels.to_vec()); + for addresses in batch { + assert!(!addresses.contains(&skipped_a)); + assert!(!addresses.contains(&skipped_b)); + } + Ok(batch.iter().map(|p| outcome(usize::from(p.len() > 1))).collect()) + }) + .unwrap(); + assert_eq!(waves, vec![vec!["1"], vec!["3"], vec!["3.0"], vec!["3.1"]]); + assert_eq!(runs.attempts, 4); + for id in [0, 2] { + assert!(runs.results[id].is_none()); + assert!(runs.parts[id].is_empty()); + } + for id in [1, 3] { + assert!(runs.results[id].as_ref().unwrap().error.is_empty()); + let mut checked: Vec<_> = + runs.parts[id].iter().flat_map(|p| p.owned.clone()).collect(); + checked.sort_unstable(); + assert_eq!(checked, owned[id]); + } + let mut report = json!({"leaves": [ + {"status": "unchanged"}, {"status": "measured"}, + {"status": "unchanged"}, {"status": "measured"} + ]}); + extend_report(&mut report, &runs); + assert_eq!(report["leaves"][0], json!({"status": "unchanged"})); + assert_eq!(report["leaves"][2], json!({"status": "unchanged"})); + assert_eq!(report["leaves"][3]["status"], "refined"); + assert_eq!(report["leaves"][3]["parts"][0]["label"], "3.0"); +} + +#[test] +fn invalid_selection_never_reaches_the_executor() { + let env = Env::new(); + let m = manifest(vec![vec![axiom(&env, 0)]]); + let owned = prepare_owned(&env, &m).unwrap(); + for selected in [vec![], vec![1], vec![usize::MAX]] { + assert!( + run(&env, &m, &owned, Some(&selected), |_, _| { + panic!("invalid selection reached execution") + }) + .is_err() + ); + } +} + +#[test] +fn a_split_child_executes_while_an_unrelated_original_is_still_active() { + use std::{sync::mpsc, time::Duration}; + let env = Env::new(); + let m = + manifest(vec![vec![axiom(&env, 0), axiom(&env, 1)], vec![axiom(&env, 2)]]); + let owned = prepare_owned(&env, &m).unwrap(); + let gate = Admission::for_test(2); + let pool = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap(); + let (slow_tx, slow_rx) = mpsc::channel(); + let (child_tx, child_rx) = mpsc::channel(); + let slow_rx = Mutex::new(slow_rx); + let child_rx = Mutex::new(child_rx); + let runs = super::run( + &env, + &m, + &owned, + None, + &gate, + &pool, + |_| 1024, + |_, label| { + match label { + "0" => { + slow_rx.lock().unwrap().recv_timeout(Duration::from_secs(3)).unwrap(); + return Ok(outcome(1)); + }, + "1" => { + slow_tx.send(()).unwrap(); + child_rx + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(3)) + .unwrap(); + }, + "0.0" => child_tx.send(()).unwrap(), + "0.1" => {}, + _ => panic!("unexpected attempt {label}"), + } + Ok(outcome(0)) + }, + ) + .unwrap(); + assert_eq!(runs.attempts, 4); + assert_eq!(runs.max_generation, 1); + assert_eq!( + runs.parts[0].iter().map(|p| p.label.as_str()).collect::>(), + ["0.0", "0.1"] + ); + for (id, parts) in runs.parts.iter().enumerate() { + let mut checked: Vec<_> = + parts.iter().flat_map(|p| p.owned.clone()).collect(); + checked.sort_unstable(); + assert_eq!(checked, owned[id]); + assert!(runs.results[id].as_ref().unwrap().error.is_empty()); + } +} + +#[test] +fn report_ownership_and_claims_are_stable_across_completion_orders() { + let env = Env::new(); + let addresses: Vec<_> = (0..12).map(|i| axiom(&env, i)).collect(); + let projection = + store(&env, &ixon::constant::defn_proj_constant(0, addresses[1].clone())); + let m = manifest(vec![ + vec![addresses[0].clone()], + addresses[1..8].to_vec(), + addresses[8..].to_vec(), + ]); + let owned = prepare_owned(&env, &m).unwrap(); + let mut reference = None; + for workers in [1, 2, 64] { + let gate = Admission::for_test(workers); + let pool = + rayon::ThreadPoolBuilder::new().num_threads(workers).build().unwrap(); + let runs = super::run( + &env, + &m, + &owned, + Some(&[2, 1]), + &gate, + &pool, + |_| 1024, + |owned, _| { + assert!(!owned.contains(&addresses[0])); + assert_eq!(owned.contains(&addresses[1]), owned.contains(&projection)); + let blocks = owned.len() - usize::from(owned.contains(&projection)); + let mut result = outcome(usize::from(blocks > 1)); + let (claim, _) = + ixon::shard_claim::shard_check_env_claim(&env, owned).unwrap(); + let mut bytes = Vec::new(); + claim.put(&mut bytes); + result.claim = Some(Address::hash(&bytes)); + Ok(result) + }, + ) + .unwrap(); + assert_eq!(runs.attempts, 20); + assert!(runs.results[0].is_none()); + for id in [1, 2] { + let mut checked: Vec<_> = + runs.parts[id].iter().flat_map(|p| p.owned.clone()).collect(); + checked.sort_unstable(); + assert_eq!(checked, owned[id]); + } + let mut report = json!({"leaves": [{"status":"unchanged"}, {}, {}]}); + extend_report(&mut report, &runs); + assert_eq!(report["scheduler"], "completion-driven"); + assert!(report["waves"].is_null()); + if let Some(reference) = &reference { + assert_eq!(&report, reference); + } else { + reference = Some(report); + } + } +} + +#[test] +fn malformed_resource_outcomes_are_not_retried_or_reported_as_success() { + let env = Env::new(); + let m = manifest(vec![vec![axiom(&env, 0), axiom(&env, 1)]]); + let owned = prepare_owned(&env, &m).unwrap(); + for malformed in 0..3 { + assert!( + run(&env, &m, &owned, None, |_, _| { + let mut result = outcome(1); + match malformed { + 0 => result.resource_status = 3, + 1 => result.error.clear(), + _ => result.peak_bytes = 1, + } + Ok(vec![result]) + }) + .err() + .unwrap() + .contains("invalid resource-limited") + ); + } +} diff --git a/crates/ffi/src/aiur/check/tests.rs b/crates/ffi/src/aiur/check/tests.rs index 18952df0f..677c2b68d 100644 --- a/crates/ffi/src/aiur/check/tests.rs +++ b/crates/ffi/src/aiur/check/tests.rs @@ -2,7 +2,7 @@ use super::*; use ix_kernel::shard::{AggNode, ShardInfo}; use ixon::{Constant, constant::Axiom, expr::Expr}; -fn store(env: &Env, constant: &Constant) -> Address { +pub(super) fn store(env: &Env, constant: &Constant) -> Address { let mut bytes = Vec::new(); constant.put(&mut bytes); let addr = Address::hash(&bytes); @@ -11,7 +11,7 @@ fn store(env: &Env, constant: &Constant) -> Address { addr } -fn axiom(env: &Env, level: u64) -> Address { +pub(super) fn axiom(env: &Env, level: u64) -> Address { store( env, &Constant { @@ -27,7 +27,7 @@ fn axiom(env: &Env, level: u64) -> Address { ) } -fn manifest(lists: Vec>) -> ShardManifest { +pub(super) fn manifest(lists: Vec>) -> ShardManifest { ShardManifest { num_shards: u32::try_from(lists.len()).unwrap(), shards: lists @@ -159,19 +159,40 @@ fn native_ownership_and_error_order_are_deterministic_across_pool_widths() { let mut addresses: Vec<_> = (0..40).map(|i| axiom(&env, i)).collect(); addresses.sort_unstable(); let m = manifest(vec![addresses.iter().cloned().rev().collect()]); - let run = |width, manifest: &ShardManifest| { - rayon::ThreadPoolBuilder::new() - .num_threads(width) - .build() - .unwrap() - .install(|| prepare_owned(&env, manifest)) - }; + let run = + |width, manifest: &ShardManifest| prepare_with_pool(&env, manifest, width); assert_eq!(run(1, &m).unwrap(), run(4, &m).unwrap()); assert_eq!(run(4, &m).unwrap()[0], addresses); let missing = manifest(vec![vec![]]); assert_eq!(run(1, &missing).unwrap_err(), run(4, &missing).unwrap_err()); } +#[test] +fn setup_width_is_bounded_by_default_and_explicit_settings_are_validated() { + for (available, expected) in [(0, 1), (1, 1), (4, 4), (64, 8), (256, 8)] { + assert_eq!(setup_pool_size(None, available).unwrap(), expected); + } + for (setting, expected) in [("1", 1), ("2", 2), ("16", 16)] { + assert_eq!(setup_pool_size(Some(setting), 64).unwrap(), expected); + } + for bad in ["", "0", "-1", "eight", "2.0", " 2", "184467440737095516160"] { + assert!(setup_pool_size(Some(bad), 64).is_err(), "{bad}"); + } +} + +#[test] +fn separate_setup_pool_does_not_widen_single_worker_execution() { + let env = Env::new(); + let addresses = (0..40).map(|i| axiom(&env, i)).collect::>(); + let m = manifest(vec![addresses]); + let owned = prepare_with_pool(&env, &m, 4).unwrap(); + assert_eq!(owned[0].len(), 40); + let execution = + rayon::ThreadPoolBuilder::new().num_threads(1).build().unwrap(); + assert_eq!(execution.install(rayon::current_num_threads), 1); + assert_eq!(execution.install(|| prepare_owned(&env, &m)).unwrap(), owned); +} + #[test] fn native_manifest_decoder_rejects_malformed_framing() { let env = Env::new(); @@ -226,6 +247,7 @@ fn native_report_keeps_claim_identity_and_rejected_leaf_details() { revision: "test", command: "ix check", budget_source: "none", + selection: None, }; let loaded = LoadedEnv { env, @@ -234,12 +256,13 @@ fn native_report_keeps_claim_identity_and_rejected_leaf_details() { .collect(), bytes: 42, }; - let results = [ShardCheckResult { + let results = [Some(ShardCheckResult { error: "expected rejection".into(), peak_bytes: 0, suggested_parts: 1, + resource_status: 0, claim: Some(digest.clone()), - }]; + })]; let report = audit_report(&config, &loaded, &m, &m.to_bytes(), &owned, &results); assert_eq!(report["leaves"][0]["claim"], digest.hex()); @@ -250,6 +273,60 @@ fn native_report_keeps_claim_identity_and_rejected_leaf_details() { assert_eq!(report["executed"], 1); } +#[test] +fn selections_are_explicit_bounded_sorted_and_deduplicated() { + assert_eq!(select_shards(4, None).unwrap(), vec![0, 1, 2, 3]); + assert_eq!(select_shards(4, Some(&[3, 1, 3])).unwrap(), vec![1, 3]); + assert!(select_shards(4, Some(&[])).unwrap_err().contains("empty selection")); + assert!(select_shards(4, Some(&[4])).unwrap_err().contains("out of range")); + assert!(select_shards(4, Some(&[usize::MAX])).is_err()); +} + +#[test] +fn selected_report_does_not_claim_untouched_shards_were_checked() { + let env = Env::new(); + let m = manifest((0..4).map(|i| vec![axiom(&env, i)]).collect()); + let owned = prepare_owned(&env, &m).unwrap(); + let config = RunConfig { + ixe: Path::new("fixture.ixe"), + manifest: Path::new("fixture.ixes"), + jobs: 2, + use_bytecode: false, + report: "report.json", + revision: "test", + command: "ix check --shards 3", + budget_source: "none", + selection: Some(&[3]), + }; + let loaded = LoadedEnv { env, names: FxHashMap::default(), bytes: 42 }; + let results = vec![ + None, + None, + None, + Some(ShardCheckResult { + error: "expected selected rejection".into(), + peak_bytes: 0, + suggested_parts: 1, + resource_status: 0, + claim: None, + }), + ]; + let report = + audit_report(&config, &loaded, &m, &m.to_bytes(), &owned, &results); + for id in 0..3 { + assert_eq!(report["leaves"][id]["id"], id); + assert_eq!(report["leaves"][id]["status"], "unchanged"); + assert!(report["leaves"][id]["claim"].is_null()); + assert!(report["leaves"][id]["predicted_peak_bytes"].is_null()); + } + assert_eq!(report["source"]["shards"], 4); + assert_eq!(report["selected"], 1); + assert_eq!(report["executed"], 1); + assert_eq!(report["leaves"][3]["status"], "failed"); + assert_eq!(report["failures"][0]["id"], 3); + assert_eq!(report["failures"].as_array().unwrap().len(), 1); +} + /// Release-mode setup benchmark for external corpora. Deliberately does not /// execute shards: it can measure the new loader/coverage pass alongside a /// running baseline without creating a second set of execution records. diff --git a/crates/ffi/src/aiur/memory.rs b/crates/ffi/src/aiur/memory.rs new file mode 100644 index 000000000..b2cb2c880 --- /dev/null +++ b/crates/ffi/src/aiur/memory.rs @@ -0,0 +1,251 @@ +//! Host and cgroup-v2 headroom for IxVM admission. This is telemetry, not an +//! allocator limit: the supervisor must still enforce the hard memory cap. + +use std::{ + fs, + path::{Component, Path, PathBuf}, +}; + +pub(super) const GIB: u64 = 1 << 30; +const MIB: u64 = 1 << 20; + +#[derive(Clone, Copy, Debug)] +pub(super) struct Memory { + pub capacity: u64, + /// Minimum of host available RAM and every visible cgroup's headroom. + pub available: u64, + pub rss: u64, + pub swap: u64, + pub stall_us: u64, + /// System-wide full memory PSI's ten-second average, in basis points. + pub stall_avg10_bp: u64, + /// Tightest visible cgroup constraint, for diagnostics (may be memory.high). + pub cgroup: Option<(u64, u64)>, +} + +impl Memory { + pub(super) fn reserve(self) -> u64 { + (self.capacity / 5).max(64 * MIB).min(self.capacity / 2) + } + + pub(super) fn budget(self) -> u64 { + self.available.saturating_sub(self.reserve()) + } + + fn constrain(&mut self, current: u64, limit: u64) { + let headroom = limit.saturating_sub(current); + self.capacity = self.capacity.min(limit); + self.available = self.available.min(headroom); + if self + .cgroup + .is_none_or(|(used, cap)| headroom <= cap.saturating_sub(used)) + { + self.cgroup = Some((current, limit)); + } + } +} + +fn field(text: &str, key: &str) -> Result { + text + .lines() + .find_map(|line| { + line.strip_prefix(key)?.split_whitespace().next()?.parse().ok() + }) + .ok_or_else(|| format!("missing or invalid {key} in memory telemetry")) +} + +fn proc_path(text: &str) -> PathBuf { + PathBuf::from( + text + .replace("\\040", " ") + .replace("\\011", "\t") + .replace("\\012", "\n") + .replace("\\134", "\\"), + ) +} + +// Same mount/namespace resolution as the compiler's memory reader, but fail +// closed if a Linux memory hierarchy cannot be resolved instead of assuming +// the whole host is ours. Read all visible ancestors: siblings consume their +// parent's allowance even when our own memory.max is unlimited. +fn cgroup_dirs(groups: &str, mounts: &str) -> Result, String> { + let group = groups + .lines() + .find_map(|line| line.strip_prefix("0::")) + .ok_or("IxVM adaptive memory admission requires cgroup v2 on Linux")?; + let group = proc_path(group); + if !group.is_absolute() + || group.components().any(|c| c == Component::ParentDir) + { + return Err("invalid process cgroup path".into()); + } + for line in mounts.lines() { + let Some((left, right)) = line.split_once(" - ") else { + continue; + }; + if right.split_whitespace().next() != Some("cgroup2") { + continue; + } + let fields: Vec<_> = left.split_whitespace().collect(); + if fields.len() < 5 { + continue; + } + let root = proc_path(fields[3]); + let mount = proc_path(fields[4]); + if !mount.is_absolute() + || mount.components().any(|c| c == Component::ParentDir) + { + continue; + } + let relative = if group == Path::new("/") { + Path::new("") + } else if let Ok(relative) = group.strip_prefix(&root) { + relative + } else { + continue; + }; + return Ok( + mount + .join(relative) + .ancestors() + .take_while(|p| p.starts_with(&mount)) + .map(Path::to_path_buf) + .collect(), + ); + } + Err("cannot resolve the process's cgroup-v2 mount".into()) +} + +fn read(path: &Path) -> Result { + fs::read_to_string(path) + .map_err(|e| format!("memory telemetry {}: {e}", path.display())) +} + +fn optional_limit(path: &Path) -> Result, String> { + match fs::read_to_string(path) { + Ok(s) if s.trim() == "max" => Ok(None), + Ok(s) => s + .trim() + .parse() + .map(Some) + .map_err(|e| format!("invalid memory limit {}: {e}", path.display())), + // The hierarchy root and groups without the memory controller need not + // expose limit files. Other read errors must not remove a known cap. + Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None), + Err(e) => Err(format!("memory telemetry {}: {e}", path.display())), + } +} + +fn psi_full(text: &str) -> Result<(u64, u64), String> { + let error = || "missing or invalid full memory PSI telemetry".to_owned(); + let full = text.lines().find(|l| l.starts_with("full ")).ok_or_else(error)?; + let value = |key: &str| { + full.split_whitespace().find_map(|v| v.strip_prefix(key)).ok_or_else(error) + }; + let total = + value("total=")?.parse::().map_err(|e| format!("{}: {e}", error()))?; + // PSI prints percentages with two decimal places. Parse fixed point so + // NaN, infinities and malformed telemetry cannot silently disable backoff. + let (whole, fraction) = value("avg10=")?.split_once('.').ok_or_else(error)?; + if fraction.len() != 2 + || !whole.bytes().chain(fraction.bytes()).all(|b| b.is_ascii_digit()) + { + return Err(error()); + } + let avg10 = whole + .parse::() + .ok() + .and_then(|v| v.checked_mul(100)) + .and_then(|v| v.checked_add(fraction.parse::().ok()?)) + .filter(|&v| v <= 10_000) + .ok_or_else(error)?; + Ok((total, avg10)) +} + +fn optional_pressure(path: &Path) -> Result<(u64, u64), String> { + pressure_result(path, fs::read_to_string(path)) +} + +fn pressure_result( + path: &Path, + result: std::io::Result, +) -> Result<(u64, u64), String> { + match result { + Ok(text) => psi_full(&text), + // PSI may be absent or disabled at boot (EOPNOTSUPP). Headroom and swap + // checks still apply; other failures are not silently zero pressure. + Err(e) + if matches!( + e.kind(), + std::io::ErrorKind::NotFound | std::io::ErrorKind::Unsupported + ) => + { + Ok((0, 0)) + }, + Err(e) => Err(format!("memory telemetry {}: {e}", path.display())), + } +} + +pub(super) struct MemoryReader { + cgroups: Vec, +} + +impl MemoryReader { + /// No Linux telemetry on other operating systems: callers use a serial + /// fallback, never silently open a full-width unmonitored pool. + pub(super) fn new() -> Result, String> { + if !cfg!(target_os = "linux") { + return Ok(None); + } + Ok(Some(Self { + cgroups: cgroup_dirs( + &read(Path::new("/proc/self/cgroup"))?, + &read(Path::new("/proc/self/mountinfo"))?, + )?, + })) + } + + pub(super) fn read(&self) -> Result { + let mem = read(Path::new("/proc/meminfo"))?; + let status = read(Path::new("/proc/self/status"))?; + let (stall_us, stall_avg10_bp) = + optional_pressure(Path::new("/proc/pressure/memory"))?; + let mut snapshot = Memory { + capacity: field(&mem, "MemTotal:")?.saturating_mul(1024), + available: field(&mem, "MemAvailable:")?.saturating_mul(1024), + rss: field(&status, "VmRSS:")?.saturating_mul(1024), + swap: field(&status, "VmSwap:")?.saturating_mul(1024), + stall_us, + stall_avg10_bp, + cgroup: None, + }; + self.constrain(&mut snapshot)?; + Ok(snapshot) + } + + fn constrain(&self, snapshot: &mut Memory) -> Result<(), String> { + for dir in &self.cgroups { + if !dir.is_dir() { + return Err(format!("memory cgroup disappeared: {}", dir.display())); + } + // Re-read limits every sample, including previously unlimited parents. + let limits = [ + optional_limit(&dir.join("memory.max"))?, + optional_limit(&dir.join("memory.high"))?, + ]; + if limits.iter().any(Option::is_some) { + let current = + read(&dir.join("memory.current"))?.trim().parse::().map_err( + |e| format!("invalid memory.current at {}: {e}", dir.display()), + )?; + for limit in limits.into_iter().flatten() { + snapshot.constrain(current, limit); + } + } + } + Ok(()) + } +} + +#[cfg(test)] +mod tests; diff --git a/crates/ffi/src/aiur/memory/tests.rs b/crates/ffi/src/aiur/memory/tests.rs new file mode 100644 index 000000000..7c8bde569 --- /dev/null +++ b/crates/ffi/src/aiur/memory/tests.rs @@ -0,0 +1,177 @@ +use super::*; +use std::sync::atomic::{AtomicUsize, Ordering}; + +fn host() -> Memory { + Memory { + capacity: 500 * GIB, + available: 480 * GIB, + rss: 20 * GIB, + swap: 0, + stall_us: 0, + stall_avg10_bp: 0, + cgroup: None, + } +} + +#[test] +fn cgroup_headroom_subtracts_current_and_reserves_capacity() { + let mut memory = host(); + memory.constrain(60 * GIB, 420 * GIB); + assert_eq!(memory.available, 360 * GIB); + assert_eq!(memory.capacity, 420 * GIB); + assert_eq!(memory.budget(), 276 * GIB); + memory.constrain(170 * GIB, 200 * GIB); + assert_eq!(memory.available, 30 * GIB); + assert_eq!(memory.budget(), 0); + assert_eq!(memory.cgroup, Some((170 * GIB, 200 * GIB))); +} + +#[test] +fn host_pressure_and_over_limit_charges_never_wrap() { + let mut memory = Memory { available: 10 * GIB, ..host() }; + memory.constrain(20 * GIB, 420 * GIB); + assert_eq!(memory.available, 10 * GIB); + memory.constrain(421 * GIB, 420 * GIB); + assert_eq!(memory.available, 0); + memory.constrain(1, 0); + assert_eq!(memory.capacity, 0); + assert_eq!(memory.budget(), 0); +} + +#[test] +fn cgroup_paths_include_ancestors_and_namespace_root() { + let mount = "30 20 0:25 / /sys/fs/cgroup rw - cgroup2 cgroup rw"; + assert_eq!( + cgroup_dirs("0::/a/b\n", mount).unwrap(), + vec![ + PathBuf::from("/sys/fs/cgroup/a/b"), + PathBuf::from("/sys/fs/cgroup/a"), + PathBuf::from("/sys/fs/cgroup") + ] + ); + let namespaced = + "30 20 0:25 /host/container /cg\\040mount rw - cgroup2 cgroup rw"; + assert_eq!( + cgroup_dirs("0::/\n", namespaced).unwrap(), + vec![PathBuf::from("/cg mount")] + ); + assert_eq!( + cgroup_dirs("0::/host/container/child\n", namespaced).unwrap(), + vec![PathBuf::from("/cg mount/child"), PathBuf::from("/cg mount")] + ); + for group in ["0::/../../escape", "0::relative", "1:memory:/old"] { + assert!(cgroup_dirs(group, mount).is_err()); + } + assert!(cgroup_dirs("0::/a", "bad mountinfo").is_err()); +} + +static NEXT_DIR: AtomicUsize = AtomicUsize::new(0); +struct TempDir(PathBuf); +impl TempDir { + fn new() -> Self { + let path = std::env::temp_dir().join(format!( + "ix-memory-test-{}-{}", + std::process::id(), + NEXT_DIR.fetch_add(1, Ordering::Relaxed) + )); + fs::create_dir(&path).unwrap(); + Self(path) + } +} +impl Drop for TempDir { + fn drop(&mut self) { + fs::remove_dir_all(&self.0).unwrap(); + } +} + +#[test] +fn unlimited_child_still_obeys_parent_and_live_high_changes() { + let dir = TempDir::new(); + let child = dir.0.join("child"); + fs::create_dir(&child).unwrap(); + for path in [&dir.0, &child] { + fs::write(path.join("memory.max"), "max\n").unwrap(); + fs::write(path.join("memory.high"), "max\n").unwrap(); + } + fs::write(dir.0.join("memory.current"), (100 * GIB).to_string()).unwrap(); + fs::write(dir.0.join("memory.max"), (420 * GIB).to_string()).unwrap(); + let reader = MemoryReader { cgroups: vec![child.clone(), dir.0.clone()] }; + let mut memory = host(); + reader.constrain(&mut memory).unwrap(); + assert_eq!(memory.available, 320 * GIB); + // The child's previously unlimited high limit changes during execution. + fs::write(child.join("memory.high"), (50 * GIB).to_string()).unwrap(); + fs::write(child.join("memory.current"), (30 * GIB).to_string()).unwrap(); + let mut memory = host(); + reader.constrain(&mut memory).unwrap(); + assert_eq!(memory.available, 20 * GIB); + assert_eq!(memory.capacity, 50 * GIB); + assert_eq!(memory.cgroup, Some((30 * GIB, 50 * GIB))); + fs::remove_file(child.join("memory.current")).unwrap(); + assert!(reader.constrain(&mut host()).is_err()); + fs::write(child.join("memory.current"), "not a number").unwrap(); + assert!(reader.constrain(&mut host()).is_err()); + fs::write(child.join("memory.high"), "not a limit").unwrap(); + assert!(reader.constrain(&mut host()).is_err()); +} + +#[test] +fn missing_telemetry_does_not_become_an_unlimited_group() { + let dir = TempDir::new(); + let reader = MemoryReader { cgroups: vec![dir.0.join("missing")] }; + assert!(reader.constrain(&mut host()).is_err()); + assert_eq!(field("VmRSS: 123 kB\n", "VmRSS:").unwrap(), 123); + assert!(field("VmRSS: nope\n", "VmRSS:").is_err()); +} + +#[test] +fn psi_reads_full_stalls_and_fixed_point_trend_without_silent_bad_values() { + assert_eq!( + psi_full("some avg10=99.00 total=777\nfull avg10=2.50 avg60=1.00 avg300=0.00 total=12345\n") + .unwrap(), + (12345, 250) + ); + assert_eq!(psi_full("full avg10=100.00 total=0").unwrap(), (0, 10_000)); + for text in [ + "some avg10=0.00 total=0", + "full total=0", + "full avg10=0.00 total=bad", + "full avg10=NaN total=0", + "full avg10=inf total=0", + "full avg10=-1.00 total=0", + "full avg10=0.+1 total=0", + "full avg10=1.001 total=0", + "full avg10=100.01 total=0", + "full avg10=18446744073709551615.00 total=0", + ] { + assert!(psi_full(text).is_err(), "accepted {text}"); + } + let dir = TempDir::new(); + let path = dir.0.join("memory.pressure"); + assert_eq!(optional_pressure(&path).unwrap(), (0, 0)); + assert_eq!( + pressure_result(&path, Err(std::io::ErrorKind::Unsupported.into())) + .unwrap(), + (0, 0) + ); + for kind in [std::io::ErrorKind::PermissionDenied, std::io::ErrorKind::Other] + { + assert!(pressure_result(&path, Err(kind.into())).is_err()); + } + fs::write(&path, "broken telemetry").unwrap(); + assert!(optional_pressure(&path).is_err()); + // Read errors other than an absent optional file must also fail closed. + assert!(optional_pressure(&dir.0).is_err()); +} + +#[test] +#[ignore = "prints live process memory constraints for external cgroup smoke tests"] +fn live_memory_probe() { + let memory = MemoryReader::new().unwrap().unwrap().read().unwrap(); + eprintln!("[ixvm_memory_probe] {memory:?}; budget={}", memory.budget()); + if let Ok(expected) = std::env::var("IX_TEST_MEMORY_MAX_BYTES") { + assert_eq!(memory.capacity, expected.parse::().unwrap()); + assert!(memory.available <= memory.capacity); + assert!(memory.cgroup.is_some()); + } +} diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 27737bd91..d7a638863 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -3,11 +3,12 @@ use multi_stark::{ types::{CommitmentParameters, FriParameters}, }; use rustc_hash::{FxBuildHasher, FxHashMap}; -use std::sync::LazyLock; +use std::sync::{Arc, LazyLock}; use lean_ffi::object::{ ExternalClass, LeanArray, LeanBorrowed, LeanByteArray, LeanExcept, - LeanExternal, LeanNat, LeanOption, LeanOwned, LeanProd, LeanRef, LeanString, + LeanExternal, LeanIOResult, LeanNat, LeanOption, LeanOwned, LeanProd, + LeanRef, LeanString, }; use crate::{ @@ -21,7 +22,9 @@ use crate::{ }; use aiur::{ G, - execute::{IOBuffer, IOKeyInfo, QueryRecord}, + execute::{ + ExecError, IOBuffer, IOKeyInfo, QueryRecord, budget::ExecutionBudget, + }, synthesis::{AiurProof, AiurSystem, CircuitShape, GatedProve}, }; @@ -463,20 +466,36 @@ fn dispatch_execute( io_buffer: &mut IOBuffer, use_bytecode: bool, ) -> Result<(QueryRecord, Vec), String> { + dispatch_execute_with_budget( + toplevel, + fun_idx, + input, + io_buffer, + use_bytecode, + None, + ) + .map_err(|e| format!("execute_ixvm: {e}")) +} + +fn dispatch_execute_with_budget( + toplevel: &aiur::bytecode::Toplevel, + fun_idx: aiur::bytecode::FunIdx, + input: Vec, + io_buffer: &mut IOBuffer, + use_bytecode: bool, + budget: Option>, +) -> Result<(QueryRecord, Vec), ExecError> { // Same span name as the prove pipeline's execution phase // (`synthesis.rs`), so a standalone execute renders/records through the // one texray channel — timing and RAM come from the subscriber, not // per-benchmark arithmetic. let _g = tracing::info_span!("aiur/execute_ixvm").entered(); if use_bytecode { - toplevel - .execute(fun_idx, input, io_buffer) - .map_err(|e| format!("execute (bytecode): {e}")) + toplevel.execute_with_budget(fun_idx, input, io_buffer, budget) } else { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, + ixvm_codegen::aiur_ixvm_runner::execute_ixvm_with_budget( + toplevel, fun_idx, input, io_buffer, budget, ) - .map_err(|e| format!("execute_ixvm: {e}")) } } @@ -642,36 +661,7 @@ pub(crate) fn decode_addr_lists( Ok(lists) } -/// Byte-weighted admission gate: a counting semaphore over estimated -/// execution RSS, expressed with the std Mutex+Condvar construction. -/// Bounds MEMORY in flight instead of shards in flight, so the rayon -/// pool can run at full width: cheap shards run many-wide while a -/// heavy one takes a proportional slice of the budget. Workers block -/// in `acquire` until reserving their estimate fits the budget. -struct RamGate { - reserved: std::sync::Mutex, - cv: std::sync::Condvar, - budget: usize, -} - -impl RamGate { - fn acquire(&self, bytes: usize) { - let mut used = self.reserved.lock().unwrap(); - // Admit-when-alone: a shard whose estimate alone exceeds the - // budget must still run (by itself) rather than deadlock. - while *used > 0 && *used + bytes > self.budget { - used = self.cv.wait(used).unwrap(); - } - *used += bytes; - } - - fn release(&self, bytes: usize) { - *self.reserved.lock().unwrap() -= bytes; - self.cv.notify_all(); - } -} - -/// Per-shard execution-RSS reserve for [`RamGate`], an AFFINE model: +/// Per-shard execution-RSS estimate, an AFFINE model: /// `EXEC_RSS_FIXED_BYTES + EXEC_RSS_PER_OWNED_BYTE x owned bytes`. The /// byte basis is the sum of the shard's owned constants' raw /// serialized bytes (`Env::get_const_bytes`) — NOT the shard's share @@ -687,7 +677,7 @@ impl RamGate { const EXEC_RSS_FIXED_BYTES: usize = 9 * (1 << 29); // 4.5 GiB // Two calibrations, each accurate in its own regime, combined as a MAX // in `exec_rss_estimate` because the per-owned-byte execution footprint -// is env-dependent and the gate's contract is NEVER OOM: +// is env-dependent. Neither calibration is a proven memory upper bound: // - The affine fit (4.5 GiB + 1100x) measured on ISLB's small shards // (1.4-5.7 MB owned; a pure ratio under-reserved them and OOM'd a // 128 GB box). @@ -711,36 +701,22 @@ fn exec_rss_estimate(owned_bytes: usize) -> usize { .max(owned_bytes.saturating_mul(EXEC_RSS_RATIO_PER_OWNED_BYTE)) } -/// FFI: the detected prover/execution RAM budget in bytes -/// ([`detected_ram_budget`]: [`ix_kernel::shard::RAM_USABLE_FRAC`] of -/// `MemAvailable`), or `0` when `/proc/meminfo` is unreadable — the caller -/// decides whether to fail closed. +/// FFI: the detected prover RAM budget, respecting both host and visible +/// cgroup headroom, or 0 when telemetry is unavailable. Shard-batch execution +/// has its own live, fail-closed admission controller. #[unsafe(no_mangle)] -extern "C" fn rs_aiur_detected_ram_budget() --> lean_ffi::object::LeanIOResult { +extern "C" fn rs_aiur_detected_ram_budget() -> LeanIOResult { let bytes = detected_ram_budget().unwrap_or(0); - lean_ffi::object::LeanIOResult::ok(LeanOwned::box_u64(bytes as u64)) + LeanIOResult::ok(LeanOwned::box_u64(bytes as u64)) } -/// Detected prover/execution RAM budget: -/// [`ix_kernel::shard::RAM_USABLE_FRAC`] of `MemAvailable`, reserving -/// the rest for the OS. `None` (no gate) when meminfo is unreadable — -/// disabling the check beats guessing at it. +/// One-shot prover budget: the usual usable fraction of current headroom, +/// including cgroup limits and their existing charges (not host RAM alone). #[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] #[allow(clippy::cast_sign_loss)] // MemAvailable and the fraction are positive fn detected_ram_budget() -> Option { - available_ram_bytes() - .map(|b| (b as f64 * ix_kernel::shard::RAM_USABLE_FRAC) as usize) -} - -/// `MemAvailable` from `/proc/meminfo`, in bytes (Linux; includes -/// reclaimable page cache). `None` if unreadable — the caller then -/// disables the gate rather than guessing. -fn available_ram_bytes() -> Option { - let s = std::fs::read_to_string("/proc/meminfo").ok()?; - let rest = s.lines().find_map(|l| l.strip_prefix("MemAvailable:"))?; - let kib: usize = rest.trim().trim_end_matches("kB").trim().parse().ok()?; - Some(kib * 1024) + let memory = super::memory::MemoryReader::new().ok()??.read().ok()?; + Some((memory.available as f64 * ix_kernel::shard::RAM_USABLE_FRAC) as usize) } // cast_precision_loss: the [ram-gate] line renders byte counts in GiB @@ -760,59 +736,191 @@ extern "C" fn rs_aiur_toplevel_shard_check_batch( commitment_parameters: LeanAiurCommitmentParameters>, fri_parameters: LeanAiurFriParameters>, max_ram_bytes: LeanNat>, -) -> LeanExcept { - let toplevel = decode_toplevel(&toplevel_obj); - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let jobs = lean_unbox_nat_as_usize(jobs.inner()); - let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); - let shards = match decode_addr_lists(shards_blob.as_bytes()) { - Ok(v) => v, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - // One system build for the whole batch: the RAM model reads circuit - // widths and lookup counts off the compiled circuits. - let system = AiurSystem::build( - decode_toplevel(&toplevel_obj), - decode_commitment_parameters(&commitment_parameters), - decode_fri_parameters(&fri_parameters), - ); - let results = match check_shard_batch( - &toplevel, - fun_idx, - env, - &shards, - use_bytecode, - jobs, - &system, - max_ram_bytes, - false, - ) { - Ok(results) => results, - Err(error) => return LeanExcept::error_string(&error), - }; - let arr = LeanArray::alloc(results.len()); - for (i, result) in results.iter().enumerate() { - let row = LeanAiurShardResult::alloc(0); - row.set_obj(0, LeanString::new(&result.error)); - row.set_obj(1, LeanOwned::box_usize(result.peak_bytes)); - row.set_obj(2, LeanOwned::box_usize(result.suggested_parts)); - arr.set(i, row); - } - LeanExcept::ok(arr) +) -> LeanIOResult { + LeanIOResult::ok(ffi_catch_unwind_except("shardCheckBatchWithEnv", || { + let toplevel = decode_toplevel(&toplevel_obj); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let jobs = lean_unbox_nat_as_usize(jobs.inner()); + let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); + let shards = match decode_addr_lists(shards_blob.as_bytes()) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), + }; + let env = &env_handle.get().env; + // One system build for the whole batch: the RAM model reads circuit + // widths and lookup counts off the compiled circuits. + let system = AiurSystem::build( + decode_toplevel(&toplevel_obj), + decode_commitment_parameters(&commitment_parameters), + decode_fri_parameters(&fri_parameters), + ); + let pool = match rayon::ThreadPoolBuilder::new().num_threads(jobs).build() { + Ok(pool) => pool, + Err(e) => return LeanExcept::error_string(&format!("rayon pool: {e}")), + }; + let results = match check_shard_batch( + &toplevel, + fun_idx, + env, + &shards, + use_bytecode, + &pool, + &system, + max_ram_bytes, + false, + &[], + ) { + Ok(results) => results, + Err(error) => return LeanExcept::error_string(&error), + }; + let arr = LeanArray::alloc(results.len()); + for (i, result) in results.iter().enumerate() { + let row = LeanAiurShardResult::alloc(0); + row.set_obj(0, LeanString::new(&result.error)); + row.set_obj(1, LeanOwned::box_usize(result.peak_bytes)); + row.set_obj(2, LeanOwned::box_usize(result.suggested_parts)); + row.set_obj(3, LeanOwned::box_usize(result.resource_status)); + arr.set(i, row); + } + LeanExcept::ok(arr) + })) } +#[derive(Clone)] pub(super) struct ShardCheckResult { pub error: String, pub peak_bytes: usize, pub suggested_parts: usize, + /// 0 = completed/rejected, 1 = per-record limit (split), 2 = aggregate + /// record limit (retry after the other records have dropped). + pub resource_status: usize, /// Digest of the exact claim supplied to execution, retained for reports. pub claim: Option, } -/// Shared executor for the legacy Lean wave driver and native whole-partition -/// setup. Witness construction, kernel dispatch, record lifetime, and the RAM -/// gate must stay identical across the two callers. +/// One execution session shares the same hard record/batch budgets across all +/// attempts. Refinement changes ownership, never constructs a second competing +/// memory controller or widens a grant while other records remain alive. +pub(super) struct ShardExecutor<'a> { + toplevel: &'a aiur::bytecode::Toplevel, + fun_idx: usize, + env: &'a ixon::Env, + use_bytecode: bool, + system: &'a AiurSystem, + max_ram_bytes: usize, + batch_budget: Arc, + record_limit: u64, +} + +impl<'a> ShardExecutor<'a> { + pub(super) fn new( + toplevel: &'a aiur::bytecode::Toplevel, + fun_idx: usize, + env: &'a ixon::Env, + use_bytecode: bool, + system: &'a AiurSystem, + max_ram_bytes: usize, + batch_limit: u64, + ) -> Result { + let batch_budget = ExecutionBudget::new(batch_limit, "batch".into(), None); + let record_limit = record_memory_limit(batch_limit)?; + eprintln!( + "[ixvm_record] execution limits: per-shard={}MiB batch={}MiB; resource-limited records are NOT successful checks", + record_limit >> 20, + batch_limit >> 20 + ); + Ok(Self { + toplevel, + fun_idx, + env, + use_bytecode, + system, + max_ram_bytes, + batch_budget, + record_limit, + }) + } + + fn raw_estimate(&self, owned: &[ix_common::address::Address]) -> usize { + exec_rss_estimate( + owned + .iter() + .filter_map(|a| self.env.get_const_bytes(a).map(|b| b.len())) + .fold(0usize, usize::saturating_add), + ) + } + + pub(super) fn reservation( + &self, + owned: &[ix_common::address::Address], + ) -> usize { + // Admission doubles the static hint. Retain the existing enforceable cap. + self + .raw_estimate(owned) + .min(usize::try_from(self.record_limit / 2).unwrap_or(usize::MAX)) + } + + /// Both execution modes and both schedulers use exactly this worker. It + /// returns only scalar results: record, witness and scratch are dropped + /// before the caller releases admission or publishes a completion. + pub(super) fn check( + &self, + owned: &[ix_common::address::Address], + label: &str, + ) -> ShardCheckResult { + let mut claim_digest = None; + let result = + match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( + self.env, owned, + ) { + Err(e) => (format!("witness build: {e}"), 0, 1, 0), + Ok((claim, input, mut io_buffer)) => { + let mut bytes = Vec::new(); + claim.put(&mut bytes); + claim_digest = Some(ix_common::address::Address::hash(&bytes)); + let record_budget = ExecutionBudget::new( + self.record_limit, + format!("shard {label}"), + Some(Arc::clone(&self.batch_budget)), + ); + match dispatch_execute_with_budget( + self.toplevel, + self.fun_idx, + input, + &mut io_buffer, + self.use_bytecode, + Some(record_budget), + ) { + Err(ExecError::ResourceLimit(e)) => { + let status = if e.shared { 2 } else { 1 }; + (e.to_string(), 0, 2, status) + }, + Err(e) => (e.to_string(), 0, 1, 0), + Ok((record, _output)) => { + let peak = self.system.peak_prove_bytes(&record).peak; + let parts = if self.max_ram_bytes > 0 && peak > self.max_ram_bytes + { + self.system.suggested_split_parts(&record, self.max_ram_bytes) + } else { + 1 + }; + (String::new(), peak, parts, 0) + }, + } + }, + }; + ShardCheckResult { + error: result.0, + peak_bytes: result.1, + suggested_parts: result.2, + resource_status: result.3, + claim: claim_digest, + } + } +} + +/// Legacy Lean wave driver's batch API. Native refinement shares its executor +/// but keeps admission and aggregate accounting alive across completions. #[allow(clippy::cast_precision_loss)] pub(super) fn check_shard_batch( toplevel: &aiur::bytecode::Toplevel, @@ -820,126 +928,85 @@ pub(super) fn check_shard_batch( env: &ixon::Env, shards: &[Vec], use_bytecode: bool, - jobs: usize, + pool: &rayon::ThreadPool, system: &AiurSystem, max_ram_bytes: usize, progress: bool, + labels: &[String], ) -> Result, String> { - use rayon::prelude::*; use std::sync::atomic::{AtomicUsize, Ordering}; let started = std::time::Instant::now(); let completed = AtomicUsize::new(0); - // RAM-gated admission: reserve each shard's estimated execution RSS - // (fixed ingress cost + owned serialized bytes x measured slope) - // against most of the RAM available at entry. Memory in flight — - // not `jobs` — is what bounds peak RSS; an unreadable meminfo - // disables the gate. - let estimates: Vec = shards - .iter() - .map(|owned| { - exec_rss_estimate( - owned - .iter() - .filter_map(|a| env.get_const_bytes(a).map(|b| b.len())) - .sum::(), - ) - }) - .collect(); - let gate = RamGate { - reserved: std::sync::Mutex::new(0), - cv: std::sync::Condvar::new(), - budget: detected_ram_budget().unwrap_or(usize::MAX), - }; + let gate = super::admission::Admission::new(pool.current_num_threads())?; + let executor = ShardExecutor::new( + toplevel, + fun_idx, + env, + use_bytecode, + system, + max_ram_bytes, + gate.execution_budget(), + )?; + let estimates: Vec<_> = + shards.iter().map(|owned| executor.raw_estimate(owned)).collect(); { let gib = 1024.0 * 1024.0 * 1024.0; let min = estimates.iter().min().copied().unwrap_or(0); let max = estimates.iter().max().copied().unwrap_or(0); eprintln!( - "[ram-gate] budget {:.1} GiB, {} shard estimates: min {:.1} / max {:.1} GiB", - gate.budget as f64 / gib, + "[ram-gate] {} raw shard estimates: min {:.1} / max {:.1} GiB; reservation safety factor=2", estimates.len(), min as f64 / gib, max as f64 / gib, ); } - let check_batch = || -> Vec { - shards - .par_iter() - .zip(estimates.par_iter()) - .enumerate() - .map(|(index, (owned, est))| { - gate.acquire(*est); - if progress { - eprintln!( - "[ixvm_check] shard {index} started ({} consts)", - owned.len() - ); - } - let mut claim_digest = None; - let result = - match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( - env, owned, - ) { - Err(e) => (format!("witness build: {e}"), 0, 1), - Ok((claim, input, mut io_buffer)) => { - let mut bytes = Vec::new(); - claim.put(&mut bytes); - claim_digest = Some(ix_common::address::Address::hash(&bytes)); - match dispatch_execute( - toplevel, - fun_idx, - input, - &mut io_buffer, - use_bytecode, - ) { - Err(e) => (e, 0, 1), - // Both reductions happen here, while the record is - // still owned by this task: it is dropped before - // `gate.release`, so admission keeps bounding peak RSS by - // the shards in flight rather than by the whole partition. - Ok((record, _output)) => { - let peak = system.peak_prove_bytes(&record).peak; - let parts = if max_ram_bytes > 0 && peak > max_ram_bytes { - system.suggested_split_parts(&record, max_ram_bytes) - } else { - 1 - }; - (String::new(), peak, parts) - }, - } - }, - }; - gate.release(*est); - let done = completed.fetch_add(1, Ordering::Relaxed) + 1; - if progress { - eprintln!( - "[ixvm_check] {done}/{} shards, {:.1}s: shard {index} {}", - shards.len(), - started.elapsed().as_secs_f64(), - if result.0.is_empty() { "ok" } else { &result.0 }, - ); - } - ShardCheckResult { - error: result.0, - peak_bytes: result.1, - suggested_parts: result.2, - claim: claim_digest, - } - }) - .collect() - }; - let results = if jobs == 0 { - check_batch() - } else { - let pool = match rayon::ThreadPoolBuilder::new().num_threads(jobs).build() { - Ok(p) => p, - Err(e) => { - return Err(format!("rayon pool: {e}")); - }, - }; - pool.install(check_batch) - }; - Ok(results) + // An enforced record cap replaces the unbounded tail of the static fit. + // Admission doubles these hints; retain the smaller enforceable ceiling. + let reservations: Vec<_> = estimates + .iter() + .map(|&estimate| { + estimate + .min(usize::try_from(executor.record_limit / 2).unwrap_or(usize::MAX)) + }) + .collect(); + gate.map(pool, &reservations, |index| { + let owned = &shards[index]; + let label = labels.get(index).cloned().unwrap_or_else(|| index.to_string()); + if progress { + eprintln!("[ixvm_check] shard {label} started ({} consts)", owned.len()); + } + let result = executor.check(owned, &label); + let done = completed.fetch_add(1, Ordering::Relaxed) + 1; + if progress { + eprintln!( + "[ixvm_check] {done}/{} shards, {:.1}s: shard {label} {}", + shards.len(), + started.elapsed().as_secs_f64(), + if result.error.is_empty() { "ok" } else { &result.error }, + ); + } + result + }) +} + +/// Execution storage is a different budget from the destination prover peak. +/// Default to at most 32 GiB per record, and at most half the live batch budget. +/// The byte override is also useful for small, deterministic resource tests. +fn record_memory_limit(batch: u64) -> Result { + match std::env::var("IX_AIUR_EXEC_MAX_BYTES") { + Ok(value) => value + .parse::() + .ok() + .filter(|n| *n > 0) + .map(|n| n.min(batch)) + .ok_or_else(|| { + "IX_AIUR_EXEC_MAX_BYTES must be a positive byte count".into() + }), + Err(std::env::VarError::NotPresent) => { + Ok((32u64 << 30).min(batch / 2).max(1)) + }, + Err(e) => Err(format!("IX_AIUR_EXEC_MAX_BYTES: {e}")), + } } /// `Bytecode.Toplevel.shardCheckWithEnv`: per-shard check against a @@ -1096,65 +1163,89 @@ extern "C" fn rs_aiur_system_shard_prove_with_env( owned_blob: LeanByteArray>, max_ram_bytes: LeanNat>, exec_only: bool, -) -> LeanExcept { - ffi_catch_unwind_except("AiurSystem.shardProveWithEnv", || { - let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); - let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); - let owned = match decode_owned_blob(&owned_blob) { - Ok(v) => v, - Err(e) => return LeanExcept::error_string(&e), - }; - let env = &env_handle.get().env; - - let (claim, input, mut io_buffer) = - match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( - env, &owned, +) -> LeanIOResult { + LeanIOResult::ok(ffi_catch_unwind_except( + "AiurSystem.shardProveWithEnv", + || { + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let max_ram_bytes = lean_unbox_nat_as_usize(max_ram_bytes.inner()); + let owned = match decode_owned_blob(&owned_blob) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), + }; + let env = &env_handle.get().env; + + let (claim, input, mut io_buffer) = + match ixvm_codegen::aiur_ixvm_witness::build_shard_check_env_witness( + env, &owned, + ) { + Ok(t) => t, + Err(e) => { + return LeanExcept::error_string(&format!("witness build: {e}")); + }, + }; + + // 0 = detect cgroup-aware headroom. The batch execution controller also + // samples live pressure; this one-shot prover budget is not admission. + let budget = if max_ram_bytes > 0 { + Some(max_ram_bytes) + } else { + detected_ram_budget() + }; + let record_limit = match record_memory_limit( + detected_ram_budget().unwrap_or(1 << 30) as u64, ) { - Ok(t) => t, - Err(e) => { - return LeanExcept::error_string(&format!("witness build: {e}")); + Ok(limit) => limit.min(budget.unwrap_or(usize::MAX) as u64), + Err(error) => return LeanExcept::error_string(&error), + }; + let execution_budget = + ExecutionBudget::new(record_limit, "prove shard".into(), None); + let proved = aiur_system_obj.get().prove_ixvm_within_budget( + fun_idx, + &input, + &mut io_buffer, + |toplevel, fun_idx, input, io_buffer| { + ixvm_codegen::aiur_ixvm_runner::execute_ixvm_with_budget( + toplevel, + fun_idx, + input, + io_buffer, + Some(execution_budget), + ) + }, + budget, + exec_only, + ); + let (proof, peak, parts) = match proved { + GatedProve::ExecutionFailed(ExecError::ResourceLimit(error)) => { + eprintln!("[ixvm_record] {error}; execution aborted, split required"); + // 0 is UNKNOWN, not a measured zero-byte peak. >=2 parts guarantees + // exec-only/prove callers cannot accept this as a successful execution. + (LeanOption::none(), 0, 2) + }, + GatedProve::ExecutionFailed(error) => { + return LeanExcept::error_string(&error.to_string()); }, + GatedProve::Proved { proof, peak, .. } => ( + LeanOption::some(LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)), + peak, + 1, + ), + GatedProve::Split { peak, parts } => (LeanOption::none(), peak, parts), + GatedProve::Measured { peak } => (LeanOption::none(), peak, 1), }; - - // 0 = detect. Matching the check batch's gate keeps one RAM policy in - // the system rather than two that can disagree. - let budget = if max_ram_bytes > 0 { - Some(max_ram_bytes) - } else { - detected_ram_budget() - }; - let proved = aiur_system_obj.get().prove_ixvm_within_budget( - fun_idx, - &input, - &mut io_buffer, - |toplevel, fun_idx, input, io_buffer| { - ixvm_codegen::aiur_ixvm_runner::execute_ixvm( - toplevel, fun_idx, input, io_buffer, - ) - }, - budget, - exec_only, - ); - let (proof, peak, parts) = match proved { - GatedProve::Proved { proof, peak, .. } => ( - LeanOption::some(LeanExternal::alloc(&AIUR_PROOF_CLASS, proof)), - peak, - 1, - ), - GatedProve::Split { peak, parts } => (LeanOption::none(), peak, parts), - GatedProve::Measured { peak } => (LeanOption::none(), peak, 1), - }; - drop(io_buffer); - - let mut claim_bytes: Vec = Vec::new(); - claim.put(&mut claim_bytes); - let result = LeanAiurShardProveResult::alloc(0); - result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); - result.set_obj(1, proof); - result.set_obj(2, LeanOwned::box_usize(peak)); - result.set_obj(3, LeanOwned::box_usize(parts)); - LeanExcept::ok(result) - }) + drop(io_buffer); + + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let result = LeanAiurShardProveResult::alloc(0); + result.set_obj(0, LeanByteArray::from_bytes(&claim_bytes)); + result.set_obj(1, proof); + result.set_obj(2, LeanOwned::box_usize(peak)); + result.set_obj(3, LeanOwned::box_usize(parts)); + LeanExcept::ok(result) + }, + )) } /// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs index a3a52721f..5671c0de5 100644 --- a/crates/ffi/src/lean.rs +++ b/crates/ffi/src/lean.rs @@ -295,8 +295,8 @@ lean_ffi::lean_inductive! { LeanAiurProveResult [ { num_obj: 4 } ]; // claimBytes, proof, ioData, ioMap LeanAiurProveEnvResult [ { num_obj: 4 } ]; - // error, peakBytes, suggestedParts - LeanAiurShardResult [ { num_obj: 3 } ]; + // error, peakBytes, suggestedParts, resourceStatus + LeanAiurShardResult [ { num_obj: 4 } ]; // constants, shards, failures, elapsedMs LeanAiurPartitionCheckResult [ { num_obj: 4 } ]; // claimBytes, proof, peakBytes, suggestedParts diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs index b8385f1e4..b84e86dfa 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs @@ -14,23 +14,25 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; +use aiur::querymap::QueryKey; use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_less_than_value, bytes2_xor_split7_value, bytes2_xor_split4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; fn aiur_fn_0( - inp: [G; IN_0], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(0); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __ret: [G; OUT_0] = [__v_2]; - record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[0].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -39,15 +41,16 @@ const INPUT_SIZE_1: usize = 2; const IN_1: usize = 2; const OUT_1: usize = 1; fn aiur_fn_1( - inp: [G; IN_1], + inp: QueryKey, 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(1); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -80,7 +83,7 @@ fn aiur_fn_1( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -286,13 +289,13 @@ fn aiur_fn_1( 0u64 => { let __v_227: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_227]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_227]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -300,7 +303,7 @@ fn aiur_fn_1( _ => { let __v_214: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_214]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -308,7 +311,7 @@ fn aiur_fn_1( _ => { let __v_177: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_177]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -316,7 +319,7 @@ fn aiur_fn_1( _ => { let __v_140: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_140]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -324,7 +327,7 @@ fn aiur_fn_1( _ => { let __v_103: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_103]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -335,15 +338,16 @@ const INPUT_SIZE_2: usize = 2; const IN_2: usize = 2; const OUT_2: usize = 1; fn aiur_fn_2( - inp: [G; IN_2], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(2); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -376,7 +380,7 @@ fn aiur_fn_2( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -412,16 +416,16 @@ fn aiur_fn_2( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[1].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[1].bump_multiplicity(__i)?; } record.function_queries[1].output_at(__i).to_array::() }, _ => aiur_fn_1(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; - record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[2].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; - record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[2].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -432,22 +436,23 @@ const INPUT_SIZE_3: usize = 3; const IN_3: usize = 3; const OUT_3: usize = 1; fn aiur_fn_3( - inp: [G; IN_3], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(3); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_3] = [__v_5]; - record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[3].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -455,14 +460,14 @@ fn aiur_fn_3( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[3].bump_multiplicity(__i)?; } record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_3] = [__v_10]; - record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[3].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -473,20 +478,21 @@ const INPUT_SIZE_4: usize = 8; const IN_4: usize = 8; const OUT_4: usize = 1; fn aiur_fn_4( - inp: [G; IN_4], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(4); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { @@ -505,13 +511,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -519,7 +525,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -527,7 +533,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -535,7 +541,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -543,7 +549,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -551,7 +557,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -559,7 +565,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -567,7 +573,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -578,20 +584,21 @@ const INPUT_SIZE_5: usize = 8; const IN_5: usize = 8; const OUT_5: usize = 4; fn aiur_fn_5( - inp: [G; IN_5], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(5); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); @@ -599,14 +606,14 @@ fn aiur_fn_5( let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_13: G = (__v_12 * __v_12); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -615,24 +622,25 @@ const INPUT_SIZE_6: usize = 12; const IN_6: usize = 12; const OUT_6: usize = 4; fn aiur_fn_6( - inp: [G; IN_6], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; + record.checkpoint(6); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); @@ -640,8 +648,8 @@ fn aiur_fn_6( let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_12; let __vj = __v_13; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_14; let __vj = __v_15; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_u64(2); @@ -653,7 +661,7 @@ fn aiur_fn_6( return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; - record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[6].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -662,26 +670,27 @@ const INPUT_SIZE_7: usize = 8; const IN_7: usize = 8; const OUT_7: usize = 4; fn aiur_fn_7( - inp: [G; IN_7], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) }; - let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; - let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; - let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; + record.checkpoint(7); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record)? }; + let __v_9: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record)? }; + let __v_10: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record)? }; + let __v_11: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record)? }; let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; - record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[7].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -690,18 +699,19 @@ const INPUT_SIZE_8: usize = 4; const IN_8: usize = 4; const OUT_8: usize = 4; fn aiur_fn_8( - inp: [G; IN_8], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(8); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; - record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[8].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -710,18 +720,19 @@ const INPUT_SIZE_9: usize = 4; const IN_9: usize = 4; const OUT_9: usize = 4; fn aiur_fn_9( - inp: [G; IN_9], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(9); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; - record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[9].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -730,30 +741,31 @@ const INPUT_SIZE_10: usize = 8; const IN_10: usize = 8; const OUT_10: usize = 4; fn aiur_fn_10( - inp: [G; IN_10], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record) }; + record.checkpoint(10); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record)? }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record)? }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record)? }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record)? }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); @@ -761,7 +773,7 @@ fn aiur_fn_10( let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; - record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[10].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -770,30 +782,31 @@ const INPUT_SIZE_11: usize = 8; const IN_11: usize = 8; const OUT_11: usize = 4; fn aiur_fn_11( - inp: [G; IN_11], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record) }; + record.checkpoint(11); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record)? }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record)? }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record)? }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record)? }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); @@ -801,7 +814,7 @@ fn aiur_fn_11( let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; - record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[11].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -810,20 +823,21 @@ const INPUT_SIZE_12: usize = 8; const IN_12: usize = 8; const OUT_12: usize = 8; fn aiur_fn_12( - inp: [G; IN_12], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(12); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { @@ -849,7 +863,7 @@ fn aiur_fn_12( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -863,7 +877,7 @@ fn aiur_fn_12( let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -878,7 +892,7 @@ fn aiur_fn_12( let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -892,7 +906,7 @@ fn aiur_fn_12( let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -905,7 +919,7 @@ fn aiur_fn_12( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -917,7 +931,7 @@ fn aiur_fn_12( let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -928,7 +942,7 @@ fn aiur_fn_12( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -938,7 +952,7 @@ fn aiur_fn_12( let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_12] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -947,7 +961,7 @@ fn aiur_fn_12( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_12] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -958,20 +972,21 @@ const INPUT_SIZE_13: usize = 8; const IN_13: usize = 8; const OUT_13: usize = 1; fn aiur_fn_13( - inp: [G; IN_13], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(13); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); @@ -995,7 +1010,7 @@ fn aiur_fn_13( let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_13] = [__v_26]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1004,20 +1019,21 @@ const INPUT_SIZE_14: usize = 8; const IN_14: usize = 8; const OUT_14: usize = 1; fn aiur_fn_14( - inp: [G; IN_14], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(14); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(256); let __v_9: G = (__v_8 * __v_1); let __v_10: G = G::from_u64(65536); @@ -1040,7 +1056,7 @@ fn aiur_fn_14( let __v_27: G = (__v_9 + __v_26); let __v_28: G = (__v_0 + __v_27); let __ret: [G; OUT_14] = [__v_28]; - record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[14].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1049,20 +1065,21 @@ const INPUT_SIZE_15: usize = 8; const IN_15: usize = 8; const OUT_15: usize = 1; fn aiur_fn_15( - inp: [G; IN_15], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(15); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_6 + __v_9); @@ -1079,7 +1096,7 @@ fn aiur_fn_15( let __v_21: G = (__v_13 * __v_20); let __v_22: G = (__v_18 - __v_21); let __ret: [G; OUT_15] = [__v_22]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1088,13 +1105,14 @@ const INPUT_SIZE_16: usize = 1; const IN_16: usize = 1; const OUT_16: usize = 8; fn aiur_fn_16( - inp: [G; IN_16], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(16); + let __v_0: G = inp.values()[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); @@ -1104,10 +1122,10 @@ fn aiur_fn_16( let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_1; let __vj = __v_2; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_3; let __vj = __v_4; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_5; let __vj = __v_6; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_7; let __vj = __v_8; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_9: G = G::from_u64(1020); let __v_10: G = (__v_8 - __v_9); let __v_11: G = (__v_7 + __v_10); @@ -1152,7 +1170,7 @@ fn aiur_fn_16( return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1161,13 +1179,14 @@ const INPUT_SIZE_17: usize = 1; const IN_17: usize = 1; const OUT_17: usize = 1; fn aiur_fn_17( - inp: [G; IN_17], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(17); + let __v_0: G = inp.values()[0]; let __v_1: G = g_inverse_value(__v_0); let __v_2: G = (__v_0 * __v_1); let __v_3: G = G::from_u64(1); @@ -1183,7 +1202,7 @@ fn aiur_fn_17( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_17] = [__v_1]; - record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[17].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1192,20 +1211,21 @@ const INPUT_SIZE_18: usize = 4; const IN_18: usize = 4; const OUT_18: usize = 2; fn aiur_fn_18( - inp: [G; IN_18], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(18); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 + __v_2); let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_18] = [__v_4, __v_5]; - record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[18].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1214,20 +1234,21 @@ const INPUT_SIZE_19: usize = 4; const IN_19: usize = 4; const OUT_19: usize = 2; fn aiur_fn_19( - inp: [G; IN_19], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(19); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_19] = [__v_4, __v_5]; - record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[19].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1236,20 +1257,21 @@ const INPUT_SIZE_20: usize = 2; const IN_20: usize = 2; const OUT_20: usize = 2; fn aiur_fn_20( - inp: [G; IN_20], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(20); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); let __v_3: G = (__v_2 - __v_0); let __v_4: G = G::from_u64(0); let __v_5: G = (__v_4 - __v_1); let __ret: [G; OUT_20] = [__v_3, __v_5]; - record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[20].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1258,16 +1280,17 @@ const INPUT_SIZE_21: usize = 4; const IN_21: usize = 4; const OUT_21: usize = 2; fn aiur_fn_21( - inp: [G; IN_21], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(21); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_1 * __v_3); @@ -1277,7 +1300,7 @@ fn aiur_fn_21( let __v_10: G = (__v_1 * __v_2); let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_21] = [__v_8, __v_11]; - record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[21].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1286,14 +1309,15 @@ const INPUT_SIZE_22: usize = 2; const IN_22: usize = 2; const OUT_22: usize = 2; fn aiur_fn_22( - inp: [G; IN_22], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(22); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = (__v_0 * __v_0); let __v_3: G = G::from_u64(7); let __v_4: G = (__v_1 * __v_1); @@ -1318,7 +1342,7 @@ fn aiur_fn_22( let __v_17: G = (__v_16 - __v_1); let __v_18: G = (__v_17 * __v_7); let __ret: [G; OUT_22] = [__v_15, __v_18]; - record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[22].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1327,16 +1351,17 @@ const INPUT_SIZE_23: usize = 4; const IN_23: usize = 4; const OUT_23: usize = 2; fn aiur_fn_23( - inp: [G; IN_23], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(23); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_2 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_3 * __v_3); @@ -1369,7 +1394,7 @@ fn aiur_fn_23( let __v_27: G = (__v_1 * __v_17); let __v_28: G = (__v_26 + __v_27); let __ret: [G; OUT_23] = [__v_25, __v_28]; - record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[23].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1378,23 +1403,24 @@ const INPUT_SIZE_24: usize = 4; const IN_24: usize = 4; const OUT_24: usize = 1; fn aiur_fn_24( - inp: [G; IN_24], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(24); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_1 - __v_3); let __v_7: G = G::from_bool((__v_6 == G::ZERO)); let __v_8: G = (__v_5 * __v_7); let __ret: [G; OUT_24] = [__v_8]; - record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[24].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1403,30 +1429,31 @@ const INPUT_SIZE_25: usize = 1; const IN_25: usize = 1; const OUT_25: usize = 2; fn aiur_fn_25( - inp: [G; IN_25], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(25); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_25] = [__v_2, __v_3]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_25] = [__v_4, __v_7]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -1440,39 +1467,40 @@ const INPUT_SIZE_26: usize = 1; const IN_26: usize = 1; const OUT_26: usize = 9; fn aiur_fn_26( - inp: [G; IN_26], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + record.checkpoint(26); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_26] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; - record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[26].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1481,14 +1509,15 @@ const INPUT_SIZE_27: usize = 1; const IN_27: usize = 1; const OUT_27: usize = 2; fn aiur_fn_27( - inp: [G; IN_27], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; + record.checkpoint(27); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[26].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i)?; } record.function_queries[26].output_at(__i).to_array::() }, _ => aiur_fn_26(__key, 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]; @@ -1498,10 +1527,10 @@ fn aiur_fn_27( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_10, __v_9]; - record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[27].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1510,20 +1539,21 @@ const INPUT_SIZE_28: usize = 1; const IN_28: usize = 1; const OUT_28: usize = 2; fn aiur_fn_28( - inp: [G; IN_28], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(28); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_28] = [__v_2, __v_4]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1532,13 +1562,14 @@ const INPUT_SIZE_29: usize = 1; const IN_29: usize = 1; const OUT_29: usize = 9; fn aiur_fn_29( - inp: [G; IN_29], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(29); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; @@ -1552,7 +1583,7 @@ fn aiur_fn_29( let __v_10: G = G::from_u64(8); let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; - record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[29].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1561,14 +1592,15 @@ const INPUT_SIZE_30: usize = 1; const IN_30: usize = 1; const OUT_30: usize = 2; fn aiur_fn_30( - inp: [G; IN_30], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + record.checkpoint(30); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1578,10 +1610,10 @@ fn aiur_fn_30( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_30] = [__v_10, __v_9]; - record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[30].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1590,14 +1622,15 @@ const INPUT_SIZE_31: usize = 1; const IN_31: usize = 1; const OUT_31: usize = 3; fn aiur_fn_31( - inp: [G; IN_31], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + record.checkpoint(31); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1607,7 +1640,7 @@ fn aiur_fn_31( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1660,7 +1693,7 @@ fn aiur_fn_31( let __v_59: G = (__v_41 + __v_58); let __v_60: G = (__v_10 + __v_59); let __ret: [G; OUT_31] = [__v_39, __v_60, __v_18]; - record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[31].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1669,14 +1702,15 @@ const INPUT_SIZE_32: usize = 1; const IN_32: usize = 1; const OUT_32: usize = 33; fn aiur_fn_32( - inp: [G; IN_32], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + record.checkpoint(32); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1686,7 +1720,7 @@ fn aiur_fn_32( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1696,7 +1730,7 @@ fn aiur_fn_32( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1706,7 +1740,7 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1717,7 +1751,7 @@ fn aiur_fn_32( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[32].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1726,21 +1760,22 @@ const INPUT_SIZE_33: usize = 1; const IN_33: usize = 1; const OUT_33: usize = 2; fn aiur_fn_33( - inp: [G; IN_33], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(33); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_33] = [__v_3, __v_4]; - record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[33].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1749,36 +1784,37 @@ const INPUT_SIZE_34: usize = 2; const IN_34: usize = 2; const OUT_34: usize = 2; fn aiur_fn_34( - inp: [G; IN_34], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(34); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_34] = [__v_4, __v_0]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_34] = [__v_9, __v_7]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1789,21 +1825,22 @@ const INPUT_SIZE_35: usize = 1; const IN_35: usize = 1; const OUT_35: usize = 2; fn aiur_fn_35( - inp: [G; IN_35], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(35); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_35] = [__v_3, __v_4]; - record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[35].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1812,25 +1849,26 @@ const INPUT_SIZE_36: usize = 2; const IN_36: usize = 2; const OUT_36: usize = 2; fn aiur_fn_36( - inp: [G; IN_36], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(36); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_4, __v_0]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1842,13 +1880,13 @@ fn aiur_fn_36( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_16, __v_14]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1859,21 +1897,22 @@ const INPUT_SIZE_37: usize = 1; const IN_37: usize = 1; const OUT_37: usize = 2; fn aiur_fn_37( - inp: [G; IN_37], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(37); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_37] = [__v_3, __v_4]; - record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[37].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1882,25 +1921,26 @@ const INPUT_SIZE_38: usize = 2; const IN_38: usize = 2; const OUT_38: usize = 2; fn aiur_fn_38( - inp: [G; IN_38], + inp: QueryKey, 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 __v_1: G = inp[1]; + record.checkpoint(38); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_4, __v_0]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1910,7 +1950,7 @@ fn aiur_fn_38( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1964,13 +2004,13 @@ fn aiur_fn_38( let __v_61: G = (__v_11 + __v_60); let __v_62: G = G::from_u64(1); let __v_63: G = (__v_1 - __v_62); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_67, __v_65]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1981,21 +2021,22 @@ const INPUT_SIZE_39: usize = 1; const IN_39: usize = 1; const OUT_39: usize = 2; fn aiur_fn_39( - inp: [G; IN_39], + inp: QueryKey, 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 __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(39); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[40].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i)?; } record.function_queries[40].output_at(__i).to_array::() }, _ => aiur_fn_40(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_39] = [__v_3, __v_4]; - record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[39].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2004,25 +2045,26 @@ const INPUT_SIZE_40: usize = 2; const IN_40: usize = 2; const OUT_40: usize = 2; fn aiur_fn_40( - inp: [G; IN_40], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(40); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_4, __v_0]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2032,7 +2074,7 @@ fn aiur_fn_40( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2042,7 +2084,7 @@ fn aiur_fn_40( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_19]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_19]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2052,7 +2094,7 @@ fn aiur_fn_40( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2064,14 +2106,14 @@ fn aiur_fn_40( let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[40].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i)?; } record.function_queries[40].output_at(__i).to_array::() }, _ => aiur_fn_40(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_44, __v_41]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2082,21 +2124,22 @@ const INPUT_SIZE_41: usize = 1; const IN_41: usize = 1; const OUT_41: usize = 2; fn aiur_fn_41( - inp: [G; IN_41], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(41); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_41] = [__v_3, __v_4]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2105,36 +2148,37 @@ const INPUT_SIZE_42: usize = 2; const IN_42: usize = 2; const OUT_42: usize = 2; fn aiur_fn_42( - inp: [G; IN_42], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(42); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_42] = [__v_4, __v_0]; - record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[42].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_42] = [__v_9, __v_7]; - record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[42].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2145,21 +2189,22 @@ const INPUT_SIZE_43: usize = 1; const IN_43: usize = 1; const OUT_43: usize = 2; fn aiur_fn_43( - inp: [G; IN_43], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(43); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_43] = [__v_3, __v_4]; - record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[43].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2168,39 +2213,40 @@ const INPUT_SIZE_44: usize = 2; const IN_44: usize = 2; const OUT_44: usize = 2; fn aiur_fn_44( - inp: [G; IN_44], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(44); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_44] = [__v_4, __v_0]; - record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[44].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_44] = [__v_11, __v_9]; - record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[44].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2211,21 +2257,22 @@ const INPUT_SIZE_45: usize = 1; const IN_45: usize = 1; const OUT_45: usize = 2; fn aiur_fn_45( - inp: [G; IN_45], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(45); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, 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]; - record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[45].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2234,36 +2281,37 @@ const INPUT_SIZE_46: usize = 2; const IN_46: usize = 2; const OUT_46: usize = 2; fn aiur_fn_46( - inp: [G; IN_46], + inp: QueryKey, 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]; + record.checkpoint(46); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_46] = [__v_4, __v_0]; - record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[46].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_46] = [__v_9, __v_7]; - record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[46].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2274,21 +2322,22 @@ const INPUT_SIZE_47: usize = 1; const IN_47: usize = 1; const OUT_47: usize = 2; fn aiur_fn_47( - inp: [G; IN_47], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(47); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_47] = [__v_3, __v_4]; - record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[47].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2297,36 +2346,37 @@ const INPUT_SIZE_48: usize = 2; const IN_48: usize = 2; const OUT_48: usize = 2; fn aiur_fn_48( - inp: [G; IN_48], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(48); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_48] = [__v_4, __v_0]; - record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[48].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[45].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i)?; } record.function_queries[45].output_at(__i).to_array::() }, _ => aiur_fn_45(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_48] = [__v_9, __v_7]; - record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[48].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2337,18 +2387,19 @@ const INPUT_SIZE_49: usize = 1; const IN_49: usize = 1; const OUT_49: usize = 2; fn aiur_fn_49( - inp: [G; IN_49], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + record.checkpoint(49); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_1, __v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2357,21 +2408,22 @@ const INPUT_SIZE_50: usize = 1; const IN_50: usize = 1; const OUT_50: usize = 2; fn aiur_fn_50( - inp: [G; IN_50], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(50); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_3, __v_4]; - record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[50].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2380,36 +2432,37 @@ const INPUT_SIZE_51: usize = 2; const IN_51: usize = 2; const OUT_51: usize = 2; fn aiur_fn_51( - inp: [G; IN_51], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(51); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_51] = [__v_4, __v_0]; - record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[51].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_51] = [__v_9, __v_7]; - record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[51].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2420,24 +2473,25 @@ const INPUT_SIZE_52: usize = 1; const IN_52: usize = 1; const OUT_52: usize = 4; fn aiur_fn_52( - inp: [G; IN_52], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + record.checkpoint(52); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_52] = [__v_1, __v_3, __v_5, __v_6]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2446,24 +2500,25 @@ const INPUT_SIZE_53: usize = 1; const IN_53: usize = 1; const OUT_53: usize = 3; fn aiur_fn_53( - inp: [G; IN_53], + inp: QueryKey, 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_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(53); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_3, __v_5, __v_6]; - record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[53].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2472,21 +2527,22 @@ const INPUT_SIZE_54: usize = 1; const IN_54: usize = 1; const OUT_54: usize = 2; fn aiur_fn_54( - inp: [G; IN_54], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(54); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, 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]; - record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[54].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2495,42 +2551,43 @@ const INPUT_SIZE_55: usize = 2; const IN_55: usize = 2; const OUT_55: usize = 2; fn aiur_fn_55( - inp: [G; IN_55], + inp: QueryKey, 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]; + record.checkpoint(55); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_55] = [__v_4, __v_0]; - record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[55].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_55] = [__v_13, __v_11]; - record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[55].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2541,27 +2598,28 @@ const INPUT_SIZE_56: usize = 1; const IN_56: usize = 1; const OUT_56: usize = 4; fn aiur_fn_56( - inp: [G; IN_56], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + record.checkpoint(56); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_1, __v_5, __v_7, __v_8]; - record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[56].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2570,21 +2628,22 @@ const INPUT_SIZE_57: usize = 1; const IN_57: usize = 1; const OUT_57: usize = 2; fn aiur_fn_57( - inp: [G; IN_57], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(57); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_3, __v_4]; - record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[57].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2593,45 +2652,46 @@ const INPUT_SIZE_58: usize = 2; const IN_58: usize = 2; const OUT_58: usize = 2; fn aiur_fn_58( - inp: [G; IN_58], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(58); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_58] = [__v_4, __v_0]; - record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[58].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_58] = [__v_15, __v_13]; - record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[58].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2642,38 +2702,39 @@ const INPUT_SIZE_59: usize = 1; const IN_59: usize = 1; const OUT_59: usize = 14; fn aiur_fn_59( - inp: [G; IN_59], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(59); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_8, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2684,7 +2745,7 @@ fn aiur_fn_59( let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __ret: [G; OUT_59] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[59].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2693,14 +2754,15 @@ const INPUT_SIZE_60: usize = 1; const IN_60: usize = 1; const OUT_60: usize = 3; fn aiur_fn_60( - inp: [G; IN_60], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + record.checkpoint(60); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -2708,16 +2770,16 @@ fn aiur_fn_60( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2]; - record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[60].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4]; - record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[60].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2728,62 +2790,63 @@ const INPUT_SIZE_61: usize = 1; const IN_61: usize = 1; const OUT_61: usize = 25; fn aiur_fn_61( - inp: [G; IN_61], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(61); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_14, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_14, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_24, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_24, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_28, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_28, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_32]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_32]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; @@ -2793,21 +2856,21 @@ fn aiur_fn_61( let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[60].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i)?; } record.function_queries[60].output_at(__i).to_array::() }, _ => aiur_fn_60(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; - record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[61].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2816,16 +2879,17 @@ const INPUT_SIZE_62: usize = 4; const IN_62: usize = 4; const OUT_62: usize = 1; fn aiur_fn_62( - inp: [G; IN_62], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(62); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); @@ -2836,7 +2900,7 @@ fn aiur_fn_62( let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_62] = [__v_12]; - record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[62].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2845,44 +2909,45 @@ const INPUT_SIZE_63: usize = 32; const IN_63: usize = 32; const OUT_63: usize = 8; fn aiur_fn_63( - inp: [G; IN_63], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(63); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = G::from_u64(65536); @@ -2956,7 +3021,7 @@ fn aiur_fn_63( let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_28 + __v_102); let __ret: [G; OUT_63] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; - record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[63].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2965,13 +3030,14 @@ const INPUT_SIZE_64: usize = 1; const IN_64: usize = 1; const OUT_64: usize = 32; fn aiur_fn_64( - inp: [G; IN_64], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(64); + let __v_0: G = inp.values()[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); @@ -3006,7 +3072,7 @@ fn aiur_fn_64( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -3017,14 +3083,14 @@ fn aiur_fn_64( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3058,7 +3124,7 @@ fn aiur_fn_64( let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __ret: [G; OUT_64] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; - record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[64].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -3067,13 +3133,14 @@ const INPUT_SIZE_65: usize = 1; const IN_65: usize = 1; const OUT_65: usize = 1; fn aiur_fn_65( - inp: [G; IN_65], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(65); + let __v_0: G = inp.values()[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); @@ -3108,7 +3175,7 @@ fn aiur_fn_65( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -3119,14 +3186,14 @@ fn aiur_fn_65( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3159,9 +3226,9 @@ fn aiur_fn_65( let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; - let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_65] = [__v_84]; - record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[65].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -3170,47 +3237,48 @@ const INPUT_SIZE_66: usize = 34; const IN_66: usize = 34; const OUT_66: usize = 34; fn aiur_fn_66( - inp: [G; IN_66], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + record.checkpoint(66); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -3249,12 +3317,12 @@ fn aiur_fn_66( 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_66] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[66].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i)?; } record.function_queries[66].output_at(__i).to_array::() }, _ => aiur_fn_66(__key, 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]; @@ -3293,7 +3361,7 @@ fn aiur_fn_66( 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_66] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -3331,7 +3399,7 @@ fn aiur_fn_66( let __v_134: G = G::from_u64(205); let __v_135: G = G::from_u64(224); let __v_136: G = G::from_u64(91); - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -3402,7 +3470,7 @@ fn aiur_fn_66( let __v_202: G = G::from_u64(0); let __v_203: G = G::from_u64(0); let __v_204: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -3438,9 +3506,9 @@ fn aiur_fn_66( let __v_237: G = G::from_u64(0); let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); - let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_66] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3476,7 +3544,7 @@ fn aiur_fn_66( let __v_200: G = G::from_u64(0); let __v_201: G = G::from_u64(0); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -3512,9 +3580,9 @@ fn aiur_fn_66( let __v_235: G = G::from_u64(0); let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); - let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_66] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -3535,14 +3603,15 @@ const INPUT_SIZE_67: usize = 1; const IN_67: usize = 1; const OUT_67: usize = 32; fn aiur_fn_67( - inp: [G; IN_67], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + record.checkpoint(67); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -3579,7 +3648,7 @@ fn aiur_fn_67( let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -3617,12 +3686,12 @@ fn aiur_fn_67( match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[66].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i)?; } record.function_queries[66].output_at(__i).to_array::() }, _ => aiur_fn_66(__key, 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]; @@ -3659,7 +3728,7 @@ fn aiur_fn_67( let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_103]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_103]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3693,13 +3762,13 @@ fn aiur_fn_67( let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_67] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3733,7 +3802,7 @@ fn aiur_fn_67( let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_67] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3754,40 +3823,41 @@ const INPUT_SIZE_68: usize = 7; const IN_68: usize = 7; const OUT_68: usize = 1; fn aiur_fn_68( - inp: [G; IN_68], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(68); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[71].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i)?; } record.function_queries[71].output_at(__i).to_array::() }, _ => aiur_fn_71(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_10]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[72].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i)?; } record.function_queries[72].output_at(__i).to_array::() }, _ => aiur_fn_72(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_12]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3795,10 +3865,10 @@ fn aiur_fn_68( let __v_13: G = (__v_2 + __v_12); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_16]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -3814,399 +3884,400 @@ const INPUT_SIZE_69: usize = 1; const IN_69: usize = 1; const OUT_69: usize = 64; fn aiur_fn_69( - inp: [G; IN_69], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(69); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_69] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -4535,30 +4606,31 @@ const INPUT_SIZE_70: usize = 2; const IN_70: usize = 2; const OUT_70: usize = 1; fn aiur_fn_70( - inp: [G; IN_70], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(70); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_70] = [__v_0]; - record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[70].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[70].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i)?; } record.function_queries[70].output_at(__i).to_array::() }, _ => aiur_fn_70(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_7]; - record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[70].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -4569,18 +4641,19 @@ const INPUT_SIZE_71: usize = 6; const IN_71: usize = 6; const OUT_71: usize = 1; fn aiur_fn_71( - inp: [G; IN_71], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(71); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); @@ -4588,7 +4661,7 @@ fn aiur_fn_71( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4615,7 +4688,7 @@ fn aiur_fn_71( 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -4712,7 +4785,7 @@ fn aiur_fn_71( let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; @@ -4746,7 +4819,7 @@ fn aiur_fn_71( let __v_145: G = G::from_u64(0); let __v_146: G = G::from_u64(0); let __v_147: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -4779,70 +4852,70 @@ fn aiur_fn_71( let __v_177: G = __r_arr[29]; let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; - let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_71] = [__v_180]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -4875,15 +4948,15 @@ fn aiur_fn_71( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_71] = [__v_42]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4892,7 +4965,7 @@ fn aiur_fn_71( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -4902,9 +4975,9 @@ fn aiur_fn_71( let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[70].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i)?; } record.function_queries[70].output_at(__i).to_array::() }, _ => aiur_fn_70(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, 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]; @@ -4969,7 +5042,7 @@ fn aiur_fn_71( let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; @@ -5002,7 +5075,7 @@ fn aiur_fn_71( let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_123: G = __loaded[0]; let __v_124: G = __loaded[1]; let __v_125: G = __loaded[2]; @@ -5035,7 +5108,7 @@ fn aiur_fn_71( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -5068,9 +5141,9 @@ fn aiur_fn_71( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_71] = [__v_187]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -5081,22 +5154,23 @@ const INPUT_SIZE_72: usize = 6; const IN_72: usize = 6; const OUT_72: usize = 1; fn aiur_fn_72( - inp: [G; IN_72], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(72); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, 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]; @@ -5163,9 +5237,9 @@ fn aiur_fn_72( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; @@ -5174,7 +5248,7 @@ fn aiur_fn_72( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -5211,7 +5285,7 @@ fn aiur_fn_72( let __v_115: G = G::from_u64(205); let __v_116: G = G::from_u64(224); let __v_117: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; @@ -5244,7 +5318,7 @@ fn aiur_fn_72( let __v_147: G = __loaded[29]; let __v_148: G = __loaded[30]; let __v_149: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_150: G = __loaded[0]; let __v_151: G = __loaded[1]; let __v_152: G = __loaded[2]; @@ -5278,7 +5352,7 @@ fn aiur_fn_72( let __v_180: G = G::from_u64(0); let __v_181: G = G::from_u64(0); let __v_182: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -5311,13 +5385,13 @@ fn aiur_fn_72( let __v_212: G = __r_arr[29]; let __v_213: G = __r_arr[30]; let __v_214: G = __r_arr[31]; - let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_216: G = G::from_u64(1); let __v_217: G = G::from_u64(1); - let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_219: G = G::from_u64(0); let __v_220: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_221: G = __loaded[0]; let __v_222: G = __loaded[1]; let __v_223: G = __loaded[2]; @@ -5326,7 +5400,7 @@ fn aiur_fn_72( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[12].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i)?; } record.function_queries[12].output_at(__i).to_array::() }, _ => aiur_fn_12(__key, 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]; @@ -5335,21 +5409,21 @@ fn aiur_fn_72( let __v_234: G = __r_arr[5]; let __v_235: G = __r_arr[6]; let __v_236: G = __r_arr[7]; - let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_239: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_239]; - record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[72].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; @@ -5358,7 +5432,7 @@ fn aiur_fn_72( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -5368,7 +5442,7 @@ fn aiur_fn_72( let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; @@ -5401,7 +5475,7 @@ fn aiur_fn_72( let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_125: G = __loaded[0]; let __v_126: G = __loaded[1]; let __v_127: G = __loaded[2]; @@ -5434,7 +5508,7 @@ fn aiur_fn_72( let __v_154: G = G::from_u64(0); let __v_155: G = G::from_u64(0); let __v_156: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -5469,15 +5543,15 @@ fn aiur_fn_72( let __v_188: G = __r_arr[31]; let __v_189: G = G::from_u64(1); let __v_190: G = G::from_u64(1); - let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_192: G = G::from_u64(0); let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); - let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_196]; - record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[72].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -5488,36 +5562,37 @@ const INPUT_SIZE_73: usize = 24; const IN_73: usize = 24; const OUT_73: usize = 16; fn aiur_fn_73( - inp: [G; IN_73], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; + record.checkpoint(73); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); @@ -5525,8 +5600,8 @@ fn aiur_fn_73( let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); @@ -5537,10 +5612,10 @@ fn aiur_fn_73( if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_36: G = if unconstrained { Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record) }; - let __v_37: G = if unconstrained { Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record) }; - let __v_38: G = if unconstrained { Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record) }; - let __v_39: G = if unconstrained { Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record) }; + let __v_36: G = if unconstrained { Bytes2::validate_inputs(&__v_12, &__v_24)?; Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record)? }; + let __v_37: G = if unconstrained { Bytes2::validate_inputs(&__v_13, &__v_25)?; Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record)? }; + let __v_38: G = if unconstrained { Bytes2::validate_inputs(&__v_14, &__v_26)?; Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record)? }; + let __v_39: G = if unconstrained { Bytes2::validate_inputs(&__v_15, &__v_27)?; Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record)? }; let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8) | (__v_36.as_canonical_u64() << 16) | (__v_37.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); @@ -5548,22 +5623,22 @@ fn aiur_fn_73( let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_40)?; Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record)? }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_41)?; Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record)? }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_42)?; Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record)? }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_43)?; Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record)? }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); @@ -5577,8 +5652,8 @@ fn aiur_fn_73( let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_63: G = G::from_u64(1); let __v_64: G = (__v_62 - __v_63); let __v_65: G = G::from_u64(2); @@ -5589,10 +5664,10 @@ fn aiur_fn_73( if (__v_68 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_70: G = if unconstrained { Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record) }; - let __v_71: G = if unconstrained { Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record) }; - let __v_72: G = if unconstrained { Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record) }; - let __v_73: G = if unconstrained { Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record) }; + let __v_70: G = if unconstrained { Bytes2::validate_inputs(&__v_38, &__v_58)?; Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record)? }; + let __v_71: G = if unconstrained { Bytes2::validate_inputs(&__v_39, &__v_59)?; Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record)? }; + let __v_72: G = if unconstrained { Bytes2::validate_inputs(&__v_36, &__v_60)?; Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record)? }; + let __v_73: G = if unconstrained { Bytes2::validate_inputs(&__v_37, &__v_61)?; Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record)? }; let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_71.as_canonical_u64() << 0) | (__v_72.as_canonical_u64() << 8) | (__v_73.as_canonical_u64() << 16) | (__v_70.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_74: G = G::from_u8(__u32_bytes[0]); @@ -5600,22 +5675,22 @@ fn aiur_fn_73( let __v_76: G = G::from_u8(__u32_bytes[2]); let __v_77: G = G::from_u8(__u32_bytes[3]); let __v_78: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_74; let __vj = __v_75; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_74; let __vj = __v_75; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_76; let __vj = __v_77; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_79: G = (__v_78 * __v_78); if (__v_79 != __v_78) { return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_74)?; Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record)? }; let __v_80: G = __b2_out.0; let __v_81: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_75)?; Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record)? }; let __v_82: G = __b2_out.0; let __v_83: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_76)?; Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record)? }; let __v_84: G = __b2_out.0; let __v_85: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_77)?; Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record)? }; let __v_86: G = __b2_out.0; let __v_87: G = __b2_out.1; let __v_88: G = (__v_80 + __v_83); @@ -5623,7 +5698,7 @@ fn aiur_fn_73( let __v_90: G = (__v_84 + __v_87); let __v_91: G = (__v_86 + __v_81); let __ret: [G; OUT_73] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -5632,140 +5707,141 @@ const INPUT_SIZE_74: usize = 128; const IN_74: usize = 128; const OUT_74: usize = 128; fn aiur_fn_74( - inp: [G; IN_74], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; - let __v_106: G = inp[106]; - let __v_107: G = inp[107]; - let __v_108: G = inp[108]; - let __v_109: G = inp[109]; - let __v_110: G = inp[110]; - let __v_111: G = inp[111]; - let __v_112: G = inp[112]; - let __v_113: G = inp[113]; - let __v_114: G = inp[114]; - let __v_115: G = inp[115]; - let __v_116: G = inp[116]; - let __v_117: G = inp[117]; - let __v_118: G = inp[118]; - let __v_119: G = inp[119]; - let __v_120: G = inp[120]; - let __v_121: G = inp[121]; - let __v_122: G = inp[122]; - let __v_123: G = inp[123]; - let __v_124: G = inp[124]; - let __v_125: G = inp[125]; - let __v_126: G = inp[126]; - let __v_127: G = inp[127]; + record.checkpoint(74); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; + let __v_106: G = inp.values()[106]; + let __v_107: G = inp.values()[107]; + let __v_108: G = inp.values()[108]; + let __v_109: G = inp.values()[109]; + let __v_110: G = inp.values()[110]; + let __v_111: G = inp.values()[111]; + let __v_112: G = inp.values()[112]; + let __v_113: G = inp.values()[113]; + let __v_114: G = inp.values()[114]; + let __v_115: G = inp.values()[115]; + let __v_116: G = inp.values()[116]; + let __v_117: G = inp.values()[117]; + let __v_118: G = inp.values()[118]; + let __v_119: G = inp.values()[119]; + let __v_120: G = inp.values()[120]; + let __v_121: G = inp.values()[121]; + let __v_122: G = inp.values()[122]; + let __v_123: G = inp.values()[123]; + let __v_124: G = inp.values()[124]; + let __v_125: G = inp.values()[125]; + let __v_126: G = inp.values()[126]; + let __v_127: G = inp.values()[127]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))) + u128::from(((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8) | (__v_66.as_canonical_u64() << 16) | (__v_67.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); @@ -5773,8 +5849,8 @@ fn aiur_fn_74( let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_128; let __vj = __v_129; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_130; let __vj = __v_131; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); @@ -5785,10 +5861,10 @@ fn aiur_fn_74( if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_140: G = if unconstrained { Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record) }; - let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) }; + let __v_140: G = if unconstrained { Bytes2::validate_inputs(&__v_48, &__v_128)?; Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record)? }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_49, &__v_129)?; Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_50, &__v_130)?; Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_51, &__v_131)?; Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record)? }; let __u32_sum: u128 = u128::from(((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8) | (__v_34.as_canonical_u64() << 16) | (__v_35.as_canonical_u64() << 24))) + u128::from(((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8) | (__v_140.as_canonical_u64() << 16) | (__v_141.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); @@ -5796,22 +5872,22 @@ fn aiur_fn_74( let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_144; let __vj = __v_145; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_146; let __vj = __v_147; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_144)?; Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record)? }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_145)?; Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record)? }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_146)?; Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record)? }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_147)?; Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record)? }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); @@ -5825,8 +5901,8 @@ fn aiur_fn_74( let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_162; let __vj = __v_163; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_164; let __vj = __v_165; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_167: G = G::from_u64(1); let __v_168: G = (__v_166 - __v_167); let __v_169: G = G::from_u64(2); @@ -5837,10 +5913,10 @@ fn aiur_fn_74( if (__v_172 != __v_173) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_174: G = if unconstrained { Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record) }; - let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) }; - let __v_176: G = if unconstrained { Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record) }; - let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) }; + let __v_174: G = if unconstrained { Bytes2::validate_inputs(&__v_142, &__v_162)?; Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record)? }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_143, &__v_163)?; Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record)? }; + let __v_176: G = if unconstrained { Bytes2::validate_inputs(&__v_140, &__v_164)?; Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record)? }; + let __v_177: G = if unconstrained { Bytes2::validate_inputs(&__v_141, &__v_165)?; Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record)? }; let __u32_sum: u128 = u128::from(((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8) | (__v_146.as_canonical_u64() << 16) | (__v_147.as_canonical_u64() << 24))) + u128::from(((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8) | (__v_177.as_canonical_u64() << 16) | (__v_174.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_178: G = G::from_u8(__u32_bytes[0]); @@ -5848,22 +5924,22 @@ fn aiur_fn_74( let __v_180: G = G::from_u8(__u32_bytes[2]); let __v_181: G = G::from_u8(__u32_bytes[3]); let __v_182: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_180; let __vj = __v_181; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_178; let __vj = __v_179; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_180; let __vj = __v_181; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_183: G = (__v_182 * __v_182); if (__v_183 != __v_182) { return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_158, &__v_178)?; Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record)? }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_159, &__v_179)?; Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record)? }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_160, &__v_180)?; Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record)? }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_161, &__v_181)?; Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record)? }; let __v_190: G = __b2_out.0; let __v_191: G = __b2_out.1; let __v_192: G = (__v_184 + __v_187); @@ -5877,8 +5953,8 @@ fn aiur_fn_74( let __v_198: G = G::from_u8(__u32_bytes[2]); let __v_199: G = G::from_u8(__u32_bytes[3]); let __v_200: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_196; let __vj = __v_197; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_198; let __vj = __v_199; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_201: G = G::from_u64(1); let __v_202: G = (__v_200 - __v_201); let __v_203: G = G::from_u64(2); @@ -5889,10 +5965,10 @@ fn aiur_fn_74( if (__v_206 != __v_207) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_207.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_208: G = if unconstrained { Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record) }; - let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) }; - let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) }; - let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) }; + let __v_208: G = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_196)?; Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record)? }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_53, &__v_197)?; Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record)? }; + let __v_210: G = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_198)?; Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record)? }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_199)?; Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record)? }; let __u32_sum: u128 = u128::from(((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8) | (__v_38.as_canonical_u64() << 16) | (__v_39.as_canonical_u64() << 24))) + u128::from(((__v_210.as_canonical_u64() << 0) | (__v_211.as_canonical_u64() << 8) | (__v_208.as_canonical_u64() << 16) | (__v_209.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_212: G = G::from_u8(__u32_bytes[0]); @@ -5900,22 +5976,22 @@ fn aiur_fn_74( let __v_214: G = G::from_u8(__u32_bytes[2]); let __v_215: G = G::from_u8(__u32_bytes[3]); let __v_216: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_212; let __vj = __v_213; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_214; let __vj = __v_215; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_212; let __vj = __v_213; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_214; let __vj = __v_215; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_217: G = (__v_216 * __v_216); if (__v_217 != __v_216) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_216.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_212)?; Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record)? }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_213)?; Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record)? }; let __v_220: G = __b2_out.0; let __v_221: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_214)?; Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record)? }; let __v_222: G = __b2_out.0; let __v_223: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_215)?; Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record)? }; let __v_224: G = __b2_out.0; let __v_225: G = __b2_out.1; let __v_226: G = (__v_220 + __v_223); @@ -5929,8 +6005,8 @@ fn aiur_fn_74( let __v_232: G = G::from_u8(__u32_bytes[2]); let __v_233: G = G::from_u8(__u32_bytes[3]); let __v_234: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_230; let __vj = __v_231; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_232; let __vj = __v_233; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_230; let __vj = __v_231; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_232; let __vj = __v_233; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_235: G = G::from_u64(1); let __v_236: G = (__v_234 - __v_235); let __v_237: G = G::from_u64(2); @@ -5941,10 +6017,10 @@ fn aiur_fn_74( if (__v_240 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_242: G = if unconstrained { Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record) }; - let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) }; - let __v_244: G = if unconstrained { Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record) }; - let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) }; + let __v_242: G = if unconstrained { Bytes2::validate_inputs(&__v_210, &__v_230)?; Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record)? }; + let __v_243: G = if unconstrained { Bytes2::validate_inputs(&__v_211, &__v_231)?; Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record)? }; + let __v_244: G = if unconstrained { Bytes2::validate_inputs(&__v_208, &__v_232)?; Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record)? }; + let __v_245: G = if unconstrained { Bytes2::validate_inputs(&__v_209, &__v_233)?; Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record)? }; let __u32_sum: u128 = u128::from(((__v_212.as_canonical_u64() << 0) | (__v_213.as_canonical_u64() << 8) | (__v_214.as_canonical_u64() << 16) | (__v_215.as_canonical_u64() << 24))) + u128::from(((__v_243.as_canonical_u64() << 0) | (__v_244.as_canonical_u64() << 8) | (__v_245.as_canonical_u64() << 16) | (__v_242.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_246: G = G::from_u8(__u32_bytes[0]); @@ -5952,22 +6028,22 @@ fn aiur_fn_74( let __v_248: G = G::from_u8(__u32_bytes[2]); let __v_249: G = G::from_u8(__u32_bytes[3]); let __v_250: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_246; let __vj = __v_247; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_248; let __vj = __v_249; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_246; let __vj = __v_247; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_248; let __vj = __v_249; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_251: G = (__v_250 * __v_250); if (__v_251 != __v_250) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_226, &__v_246)?; Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record)? }; let __v_252: G = __b2_out.0; let __v_253: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_227, &__v_247)?; Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record)? }; let __v_254: G = __b2_out.0; let __v_255: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_228, &__v_248)?; Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record)? }; let __v_256: G = __b2_out.0; let __v_257: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_229, &__v_249)?; Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record)? }; let __v_258: G = __b2_out.0; let __v_259: G = __b2_out.1; let __v_260: G = (__v_252 + __v_255); @@ -5981,8 +6057,8 @@ fn aiur_fn_74( let __v_266: G = G::from_u8(__u32_bytes[2]); let __v_267: G = G::from_u8(__u32_bytes[3]); let __v_268: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_264; let __vj = __v_265; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_266; let __vj = __v_267; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_264; let __vj = __v_265; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_266; let __vj = __v_267; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_269: G = G::from_u64(1); let __v_270: G = (__v_268 - __v_269); let __v_271: G = G::from_u64(2); @@ -5993,10 +6069,10 @@ fn aiur_fn_74( if (__v_274 != __v_275) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_275.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_276: G = if unconstrained { Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record) }; - let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) }; - let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) }; - let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) }; + let __v_276: G = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_264)?; Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record)? }; + let __v_277: G = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_265)?; Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record)? }; + let __v_278: G = if unconstrained { Bytes2::validate_inputs(&__v_58, &__v_266)?; Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record)? }; + let __v_279: G = if unconstrained { Bytes2::validate_inputs(&__v_59, &__v_267)?; Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record)? }; let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_278.as_canonical_u64() << 0) | (__v_279.as_canonical_u64() << 8) | (__v_276.as_canonical_u64() << 16) | (__v_277.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_280: G = G::from_u8(__u32_bytes[0]); @@ -6004,22 +6080,22 @@ fn aiur_fn_74( let __v_282: G = G::from_u8(__u32_bytes[2]); let __v_283: G = G::from_u8(__u32_bytes[3]); let __v_284: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_280; let __vj = __v_281; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_282; let __vj = __v_283; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_280; let __vj = __v_281; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_282; let __vj = __v_283; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_285: G = (__v_284 * __v_284); if (__v_285 != __v_284) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_284.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_280)?; Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record)? }; let __v_286: G = __b2_out.0; let __v_287: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_281)?; Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record)? }; let __v_288: G = __b2_out.0; let __v_289: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_282)?; Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record)? }; let __v_290: G = __b2_out.0; let __v_291: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_283)?; Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record)? }; let __v_292: G = __b2_out.0; let __v_293: G = __b2_out.1; let __v_294: G = (__v_288 + __v_291); @@ -6033,8 +6109,8 @@ fn aiur_fn_74( let __v_300: G = G::from_u8(__u32_bytes[2]); let __v_301: G = G::from_u8(__u32_bytes[3]); let __v_302: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_298; let __vj = __v_299; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_298; let __vj = __v_299; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_300; let __vj = __v_301; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_303: G = G::from_u64(1); let __v_304: G = (__v_302 - __v_303); let __v_305: G = G::from_u64(2); @@ -6045,10 +6121,10 @@ fn aiur_fn_74( if (__v_308 != __v_309) { return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_310: G = if unconstrained { Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record) }; - let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) }; - let __v_312: G = if unconstrained { Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record) }; - let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) }; + let __v_310: G = if unconstrained { Bytes2::validate_inputs(&__v_278, &__v_298)?; Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record)? }; + let __v_311: G = if unconstrained { Bytes2::validate_inputs(&__v_279, &__v_299)?; Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record)? }; + let __v_312: G = if unconstrained { Bytes2::validate_inputs(&__v_276, &__v_300)?; Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record)? }; + let __v_313: G = if unconstrained { Bytes2::validate_inputs(&__v_277, &__v_301)?; Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record)? }; let __u32_sum: u128 = u128::from(((__v_280.as_canonical_u64() << 0) | (__v_281.as_canonical_u64() << 8) | (__v_282.as_canonical_u64() << 16) | (__v_283.as_canonical_u64() << 24))) + u128::from(((__v_311.as_canonical_u64() << 0) | (__v_312.as_canonical_u64() << 8) | (__v_313.as_canonical_u64() << 16) | (__v_310.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_314: G = G::from_u8(__u32_bytes[0]); @@ -6056,22 +6132,22 @@ fn aiur_fn_74( let __v_316: G = G::from_u8(__u32_bytes[2]); let __v_317: G = G::from_u8(__u32_bytes[3]); let __v_318: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_314; let __vj = __v_315; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_316; let __vj = __v_317; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_314; let __vj = __v_315; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_316; let __vj = __v_317; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_319: G = (__v_318 * __v_318); if (__v_319 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_319.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_294, &__v_314)?; Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record)? }; let __v_320: G = __b2_out.0; let __v_321: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_295, &__v_315)?; Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record)? }; let __v_322: G = __b2_out.0; let __v_323: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_296, &__v_316)?; Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record)? }; let __v_324: G = __b2_out.0; let __v_325: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_297, &__v_317)?; Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record)? }; let __v_326: G = __b2_out.0; let __v_327: G = __b2_out.1; let __v_328: G = (__v_320 + __v_323); @@ -6085,8 +6161,8 @@ fn aiur_fn_74( let __v_334: G = G::from_u8(__u32_bytes[2]); let __v_335: G = G::from_u8(__u32_bytes[3]); let __v_336: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_334; let __vj = __v_335; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_332; let __vj = __v_333; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_334; let __vj = __v_335; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_337: G = G::from_u64(1); let __v_338: G = (__v_336 - __v_337); let __v_339: G = G::from_u64(2); @@ -6097,10 +6173,10 @@ fn aiur_fn_74( if (__v_342 != __v_343) { return Err(ExecError::AssertEqMismatch { lhs: __v_342.as_canonical_u64(), rhs: __v_343.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_344: G = if unconstrained { Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record) }; - let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) }; - let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) }; - let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) }; + let __v_344: G = if unconstrained { Bytes2::validate_inputs(&__v_60, &__v_332)?; Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record)? }; + let __v_345: G = if unconstrained { Bytes2::validate_inputs(&__v_61, &__v_333)?; Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record)? }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_62, &__v_334)?; Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record)? }; + let __v_347: G = if unconstrained { Bytes2::validate_inputs(&__v_63, &__v_335)?; Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record)? }; let __u32_sum: u128 = u128::from(((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8) | (__v_46.as_canonical_u64() << 16) | (__v_47.as_canonical_u64() << 24))) + u128::from(((__v_346.as_canonical_u64() << 0) | (__v_347.as_canonical_u64() << 8) | (__v_344.as_canonical_u64() << 16) | (__v_345.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); @@ -6108,22 +6184,22 @@ fn aiur_fn_74( let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_348; let __vj = __v_349; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_350; let __vj = __v_351; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_353: G = (__v_352 * __v_352); if (__v_353 != __v_352) { return Err(ExecError::AssertEqMismatch { lhs: __v_353.as_canonical_u64(), rhs: __v_352.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_348)?; Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record)? }; let __v_354: G = __b2_out.0; let __v_355: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_349)?; Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record)? }; let __v_356: G = __b2_out.0; let __v_357: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_350)?; Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record)? }; let __v_358: G = __b2_out.0; let __v_359: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_351)?; Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record)? }; let __v_360: G = __b2_out.0; let __v_361: G = __b2_out.1; let __v_362: G = (__v_356 + __v_359); @@ -6137,8 +6213,8 @@ fn aiur_fn_74( let __v_368: G = G::from_u8(__u32_bytes[2]); let __v_369: G = G::from_u8(__u32_bytes[3]); let __v_370: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_366; let __vj = __v_367; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_368; let __vj = __v_369; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_366; let __vj = __v_367; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_368; let __vj = __v_369; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_371: G = G::from_u64(1); let __v_372: G = (__v_370 - __v_371); let __v_373: G = G::from_u64(2); @@ -6149,10 +6225,10 @@ fn aiur_fn_74( if (__v_376 != __v_377) { return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_377.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_378: G = if unconstrained { Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record) }; - let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) }; - let __v_380: G = if unconstrained { Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record) }; - let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) }; + let __v_378: G = if unconstrained { Bytes2::validate_inputs(&__v_346, &__v_366)?; Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record)? }; + let __v_379: G = if unconstrained { Bytes2::validate_inputs(&__v_347, &__v_367)?; Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record)? }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_344, &__v_368)?; Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record)? }; + let __v_381: G = if unconstrained { Bytes2::validate_inputs(&__v_345, &__v_369)?; Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record)? }; let __u32_sum: u128 = u128::from(((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8) | (__v_350.as_canonical_u64() << 16) | (__v_351.as_canonical_u64() << 24))) + u128::from(((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8) | (__v_381.as_canonical_u64() << 16) | (__v_378.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_382: G = G::from_u8(__u32_bytes[0]); @@ -6160,22 +6236,22 @@ fn aiur_fn_74( let __v_384: G = G::from_u8(__u32_bytes[2]); let __v_385: G = G::from_u8(__u32_bytes[3]); let __v_386: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_384; let __vj = __v_385; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_382; let __vj = __v_383; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_384; let __vj = __v_385; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_387: G = (__v_386 * __v_386); if (__v_387 != __v_386) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_386.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_362, &__v_382)?; Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record)? }; let __v_388: G = __b2_out.0; let __v_389: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_363, &__v_383)?; Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record)? }; let __v_390: G = __b2_out.0; let __v_391: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_364, &__v_384)?; Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record)? }; let __v_392: G = __b2_out.0; let __v_393: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_365, &__v_385)?; Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record)? }; let __v_394: G = __b2_out.0; let __v_395: G = __b2_out.1; let __v_396: G = (__v_388 + __v_391); @@ -6189,8 +6265,8 @@ fn aiur_fn_74( let __v_402: G = G::from_u8(__u32_bytes[2]); let __v_403: G = G::from_u8(__u32_bytes[3]); let __v_404: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_400; let __vj = __v_401; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_402; let __vj = __v_403; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_400; let __vj = __v_401; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_402; let __vj = __v_403; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_405: G = G::from_u64(1); let __v_406: G = (__v_404 - __v_405); let __v_407: G = G::from_u64(2); @@ -6201,10 +6277,10 @@ fn aiur_fn_74( if (__v_410 != __v_411) { return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_412: G = if unconstrained { Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record) }; - let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) }; - let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) }; - let __v_415: G = if unconstrained { Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record) }; + let __v_412: G = if unconstrained { Bytes2::validate_inputs(&__v_379, &__v_400)?; Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record)? }; + let __v_413: G = if unconstrained { Bytes2::validate_inputs(&__v_380, &__v_401)?; Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record)? }; + let __v_414: G = if unconstrained { Bytes2::validate_inputs(&__v_381, &__v_402)?; Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record)? }; + let __v_415: G = if unconstrained { Bytes2::validate_inputs(&__v_378, &__v_403)?; Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record)? }; let __u32_sum: u128 = u128::from(((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8) | (__v_316.as_canonical_u64() << 16) | (__v_317.as_canonical_u64() << 24))) + u128::from(((__v_414.as_canonical_u64() << 0) | (__v_415.as_canonical_u64() << 8) | (__v_412.as_canonical_u64() << 16) | (__v_413.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_416: G = G::from_u8(__u32_bytes[0]); @@ -6212,22 +6288,22 @@ fn aiur_fn_74( let __v_418: G = G::from_u8(__u32_bytes[2]); let __v_419: G = G::from_u8(__u32_bytes[3]); let __v_420: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_416; let __vj = __v_417; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_418; let __vj = __v_419; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_416; let __vj = __v_417; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_418; let __vj = __v_419; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_421: G = (__v_420 * __v_420); if (__v_421 != __v_420) { return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_420.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_260, &__v_416)?; Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record)? }; let __v_422: G = __b2_out.0; let __v_423: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_261, &__v_417)?; Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record)? }; let __v_424: G = __b2_out.0; let __v_425: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_418)?; Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record)? }; let __v_426: G = __b2_out.0; let __v_427: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_419)?; Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record)? }; let __v_428: G = __b2_out.0; let __v_429: G = __b2_out.1; let __v_430: G = (__v_424 + __v_427); @@ -6241,8 +6317,8 @@ fn aiur_fn_74( let __v_436: G = G::from_u8(__u32_bytes[2]); let __v_437: G = G::from_u8(__u32_bytes[3]); let __v_438: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_434; let __vj = __v_435; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_436; let __vj = __v_437; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_434; let __vj = __v_435; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_436; let __vj = __v_437; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_439: G = G::from_u64(1); let __v_440: G = (__v_438 - __v_439); let __v_441: G = G::from_u64(2); @@ -6253,10 +6329,10 @@ fn aiur_fn_74( if (__v_444 != __v_445) { return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_445.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_446: G = if unconstrained { Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record) }; - let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) }; - let __v_448: G = if unconstrained { Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record) }; - let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) }; + let __v_446: G = if unconstrained { Bytes2::validate_inputs(&__v_414, &__v_434)?; Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record)? }; + let __v_447: G = if unconstrained { Bytes2::validate_inputs(&__v_415, &__v_435)?; Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record)? }; + let __v_448: G = if unconstrained { Bytes2::validate_inputs(&__v_412, &__v_436)?; Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record)? }; + let __v_449: G = if unconstrained { Bytes2::validate_inputs(&__v_413, &__v_437)?; Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record)? }; let __u32_sum: u128 = u128::from(((__v_416.as_canonical_u64() << 0) | (__v_417.as_canonical_u64() << 8) | (__v_418.as_canonical_u64() << 16) | (__v_419.as_canonical_u64() << 24))) + u128::from(((__v_447.as_canonical_u64() << 0) | (__v_448.as_canonical_u64() << 8) | (__v_449.as_canonical_u64() << 16) | (__v_446.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_450: G = G::from_u8(__u32_bytes[0]); @@ -6264,22 +6340,22 @@ fn aiur_fn_74( let __v_452: G = G::from_u8(__u32_bytes[2]); let __v_453: G = G::from_u8(__u32_bytes[3]); let __v_454: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_450; let __vj = __v_451; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_452; let __vj = __v_453; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_450; let __vj = __v_451; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_452; let __vj = __v_453; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_455: G = (__v_454 * __v_454); if (__v_455 != __v_454) { return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_430, &__v_450)?; Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record)? }; let __v_456: G = __b2_out.0; let __v_457: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_431, &__v_451)?; Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record)? }; let __v_458: G = __b2_out.0; let __v_459: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_432, &__v_452)?; Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record)? }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_433, &__v_453)?; Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record)? }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __v_464: G = (__v_456 + __v_459); @@ -6293,8 +6369,8 @@ fn aiur_fn_74( let __v_470: G = G::from_u8(__u32_bytes[2]); let __v_471: G = G::from_u8(__u32_bytes[3]); let __v_472: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_468; let __vj = __v_469; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_470; let __vj = __v_471; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_468; let __vj = __v_469; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_470; let __vj = __v_471; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_473: G = G::from_u64(1); let __v_474: G = (__v_472 - __v_473); let __v_475: G = G::from_u64(2); @@ -6305,10 +6381,10 @@ fn aiur_fn_74( if (__v_478 != __v_479) { return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_480: G = if unconstrained { Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record) }; - let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) }; - let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) }; - let __v_483: G = if unconstrained { Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record) }; + let __v_480: G = if unconstrained { Bytes2::validate_inputs(&__v_175, &__v_468)?; Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record)? }; + let __v_481: G = if unconstrained { Bytes2::validate_inputs(&__v_176, &__v_469)?; Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record)? }; + let __v_482: G = if unconstrained { Bytes2::validate_inputs(&__v_177, &__v_470)?; Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record)? }; + let __v_483: G = if unconstrained { Bytes2::validate_inputs(&__v_174, &__v_471)?; Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record)? }; let __u32_sum: u128 = u128::from(((__v_382.as_canonical_u64() << 0) | (__v_383.as_canonical_u64() << 8) | (__v_384.as_canonical_u64() << 16) | (__v_385.as_canonical_u64() << 24))) + u128::from(((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8) | (__v_480.as_canonical_u64() << 16) | (__v_481.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_484: G = G::from_u8(__u32_bytes[0]); @@ -6316,22 +6392,22 @@ fn aiur_fn_74( let __v_486: G = G::from_u8(__u32_bytes[2]); let __v_487: G = G::from_u8(__u32_bytes[3]); let __v_488: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_484; let __vj = __v_485; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_484; let __vj = __v_485; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_486; let __vj = __v_487; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_489: G = (__v_488 * __v_488); if (__v_489 != __v_488) { return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_328, &__v_484)?; Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record)? }; let __v_490: G = __b2_out.0; let __v_491: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_329, &__v_485)?; Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record)? }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_330, &__v_486)?; Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record)? }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_331, &__v_487)?; Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record)? }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __v_498: G = (__v_492 + __v_495); @@ -6345,8 +6421,8 @@ fn aiur_fn_74( let __v_504: G = G::from_u8(__u32_bytes[2]); let __v_505: G = G::from_u8(__u32_bytes[3]); let __v_506: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_502; let __vj = __v_503; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_502; let __vj = __v_503; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_504; let __vj = __v_505; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_507: G = G::from_u64(1); let __v_508: G = (__v_506 - __v_507); let __v_509: G = G::from_u64(2); @@ -6357,10 +6433,10 @@ fn aiur_fn_74( if (__v_512 != __v_513) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_514: G = if unconstrained { Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record) }; - let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) }; - let __v_516: G = if unconstrained { Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record) }; - let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) }; + let __v_514: G = if unconstrained { Bytes2::validate_inputs(&__v_482, &__v_502)?; Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record)? }; + let __v_515: G = if unconstrained { Bytes2::validate_inputs(&__v_483, &__v_503)?; Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record)? }; + let __v_516: G = if unconstrained { Bytes2::validate_inputs(&__v_480, &__v_504)?; Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record)? }; + let __v_517: G = if unconstrained { Bytes2::validate_inputs(&__v_481, &__v_505)?; Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record)? }; let __u32_sum: u128 = u128::from(((__v_484.as_canonical_u64() << 0) | (__v_485.as_canonical_u64() << 8) | (__v_486.as_canonical_u64() << 16) | (__v_487.as_canonical_u64() << 24))) + u128::from(((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8) | (__v_517.as_canonical_u64() << 16) | (__v_514.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_518: G = G::from_u8(__u32_bytes[0]); @@ -6368,22 +6444,22 @@ fn aiur_fn_74( let __v_520: G = G::from_u8(__u32_bytes[2]); let __v_521: G = G::from_u8(__u32_bytes[3]); let __v_522: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_520; let __vj = __v_521; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_518; let __vj = __v_519; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_520; let __vj = __v_521; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_523: G = (__v_522 * __v_522); if (__v_523 != __v_522) { return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_498, &__v_518)?; Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record)? }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_499, &__v_519)?; Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record)? }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_500, &__v_520)?; Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record)? }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_501, &__v_521)?; Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record)? }; let __v_530: G = __b2_out.0; let __v_531: G = __b2_out.1; let __v_532: G = (__v_524 + __v_527); @@ -6397,8 +6473,8 @@ fn aiur_fn_74( let __v_538: G = G::from_u8(__u32_bytes[2]); let __v_539: G = G::from_u8(__u32_bytes[3]); let __v_540: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_538; let __vj = __v_539; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_536; let __vj = __v_537; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_538; let __vj = __v_539; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_541: G = G::from_u64(1); let __v_542: G = (__v_540 - __v_541); let __v_543: G = G::from_u64(2); @@ -6409,10 +6485,10 @@ fn aiur_fn_74( if (__v_546 != __v_547) { return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_547.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_548: G = if unconstrained { Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record) }; - let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) }; - let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) }; - let __v_551: G = if unconstrained { Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record) }; + let __v_548: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_536)?; Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record)? }; + let __v_549: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_537)?; Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record)? }; + let __v_550: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_538)?; Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record)? }; + let __v_551: G = if unconstrained { Bytes2::validate_inputs(&__v_242, &__v_539)?; Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record)? }; let __u32_sum: u128 = u128::from(((__v_178.as_canonical_u64() << 0) | (__v_179.as_canonical_u64() << 8) | (__v_180.as_canonical_u64() << 16) | (__v_181.as_canonical_u64() << 24))) + u128::from(((__v_550.as_canonical_u64() << 0) | (__v_551.as_canonical_u64() << 8) | (__v_548.as_canonical_u64() << 16) | (__v_549.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_552: G = G::from_u8(__u32_bytes[0]); @@ -6420,22 +6496,22 @@ fn aiur_fn_74( let __v_554: G = G::from_u8(__u32_bytes[2]); let __v_555: G = G::from_u8(__u32_bytes[3]); let __v_556: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_552; let __vj = __v_553; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_554; let __vj = __v_555; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_552; let __vj = __v_553; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_554; let __vj = __v_555; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_557: G = (__v_556 * __v_556); if (__v_557 != __v_556) { return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_396, &__v_552)?; Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record)? }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_553)?; Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record)? }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_398, &__v_554)?; Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record)? }; let __v_562: G = __b2_out.0; let __v_563: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_399, &__v_555)?; Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record)? }; let __v_564: G = __b2_out.0; let __v_565: G = __b2_out.1; let __v_566: G = (__v_560 + __v_563); @@ -6449,8 +6525,8 @@ fn aiur_fn_74( let __v_572: G = G::from_u8(__u32_bytes[2]); let __v_573: G = G::from_u8(__u32_bytes[3]); let __v_574: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_570; let __vj = __v_571; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_572; let __vj = __v_573; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_570; let __vj = __v_571; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_572; let __vj = __v_573; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_575: G = G::from_u64(1); let __v_576: G = (__v_574 - __v_575); let __v_577: G = G::from_u64(2); @@ -6461,10 +6537,10 @@ fn aiur_fn_74( if (__v_580 != __v_581) { return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_581.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_582: G = if unconstrained { Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record) }; - let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) }; - let __v_584: G = if unconstrained { Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record) }; - let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) }; + let __v_582: G = if unconstrained { Bytes2::validate_inputs(&__v_550, &__v_570)?; Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record)? }; + let __v_583: G = if unconstrained { Bytes2::validate_inputs(&__v_551, &__v_571)?; Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record)? }; + let __v_584: G = if unconstrained { Bytes2::validate_inputs(&__v_548, &__v_572)?; Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record)? }; + let __v_585: G = if unconstrained { Bytes2::validate_inputs(&__v_549, &__v_573)?; Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record)? }; let __u32_sum: u128 = u128::from(((__v_552.as_canonical_u64() << 0) | (__v_553.as_canonical_u64() << 8) | (__v_554.as_canonical_u64() << 16) | (__v_555.as_canonical_u64() << 24))) + u128::from(((__v_583.as_canonical_u64() << 0) | (__v_584.as_canonical_u64() << 8) | (__v_585.as_canonical_u64() << 16) | (__v_582.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_586: G = G::from_u8(__u32_bytes[0]); @@ -6472,22 +6548,22 @@ fn aiur_fn_74( let __v_588: G = G::from_u8(__u32_bytes[2]); let __v_589: G = G::from_u8(__u32_bytes[3]); let __v_590: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_586; let __vj = __v_587; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_588; let __vj = __v_589; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_586; let __vj = __v_587; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_588; let __vj = __v_589; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_591: G = (__v_590 * __v_590); if (__v_591 != __v_590) { return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_590.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_566, &__v_586)?; Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record)? }; let __v_592: G = __b2_out.0; let __v_593: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_567, &__v_587)?; Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record)? }; let __v_594: G = __b2_out.0; let __v_595: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_568, &__v_588)?; Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record)? }; let __v_596: G = __b2_out.0; let __v_597: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_569, &__v_589)?; Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record)? }; let __v_598: G = __b2_out.0; let __v_599: G = __b2_out.1; let __v_600: G = (__v_592 + __v_595); @@ -6501,8 +6577,8 @@ fn aiur_fn_74( let __v_606: G = G::from_u8(__u32_bytes[2]); let __v_607: G = G::from_u8(__u32_bytes[3]); let __v_608: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_604; let __vj = __v_605; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_606; let __vj = __v_607; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_604; let __vj = __v_605; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_606; let __vj = __v_607; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_609: G = G::from_u64(1); let __v_610: G = (__v_608 - __v_609); let __v_611: G = G::from_u64(2); @@ -6513,10 +6589,10 @@ fn aiur_fn_74( if (__v_614 != __v_615) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_615.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_616: G = if unconstrained { Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record) }; - let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) }; - let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) }; - let __v_619: G = if unconstrained { Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record) }; + let __v_616: G = if unconstrained { Bytes2::validate_inputs(&__v_311, &__v_604)?; Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record)? }; + let __v_617: G = if unconstrained { Bytes2::validate_inputs(&__v_312, &__v_605)?; Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record)? }; + let __v_618: G = if unconstrained { Bytes2::validate_inputs(&__v_313, &__v_606)?; Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record)? }; + let __v_619: G = if unconstrained { Bytes2::validate_inputs(&__v_310, &__v_607)?; Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record)? }; let __u32_sum: u128 = u128::from(((__v_246.as_canonical_u64() << 0) | (__v_247.as_canonical_u64() << 8) | (__v_248.as_canonical_u64() << 16) | (__v_249.as_canonical_u64() << 24))) + u128::from(((__v_618.as_canonical_u64() << 0) | (__v_619.as_canonical_u64() << 8) | (__v_616.as_canonical_u64() << 16) | (__v_617.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_620: G = G::from_u8(__u32_bytes[0]); @@ -6524,22 +6600,22 @@ fn aiur_fn_74( let __v_622: G = G::from_u8(__u32_bytes[2]); let __v_623: G = G::from_u8(__u32_bytes[3]); let __v_624: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_620; let __vj = __v_621; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_622; let __vj = __v_623; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_620; let __vj = __v_621; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_622; let __vj = __v_623; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_625: G = (__v_624 * __v_624); if (__v_625 != __v_624) { return Err(ExecError::AssertEqMismatch { lhs: __v_625.as_canonical_u64(), rhs: __v_624.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_192, &__v_620)?; Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record)? }; let __v_626: G = __b2_out.0; let __v_627: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_193, &__v_621)?; Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record)? }; let __v_628: G = __b2_out.0; let __v_629: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_194, &__v_622)?; Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record)? }; let __v_630: G = __b2_out.0; let __v_631: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_195, &__v_623)?; Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record)? }; let __v_632: G = __b2_out.0; let __v_633: G = __b2_out.1; let __v_634: G = (__v_628 + __v_631); @@ -6553,8 +6629,8 @@ fn aiur_fn_74( let __v_640: G = G::from_u8(__u32_bytes[2]); let __v_641: G = G::from_u8(__u32_bytes[3]); let __v_642: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_638; let __vj = __v_639; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_640; let __vj = __v_641; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_638; let __vj = __v_639; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_640; let __vj = __v_641; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_643: G = G::from_u64(1); let __v_644: G = (__v_642 - __v_643); let __v_645: G = G::from_u64(2); @@ -6565,10 +6641,10 @@ fn aiur_fn_74( if (__v_648 != __v_649) { return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_650: G = if unconstrained { Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record) }; - let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) }; - let __v_652: G = if unconstrained { Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record) }; - let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) }; + let __v_650: G = if unconstrained { Bytes2::validate_inputs(&__v_618, &__v_638)?; Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record)? }; + let __v_651: G = if unconstrained { Bytes2::validate_inputs(&__v_619, &__v_639)?; Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record)? }; + let __v_652: G = if unconstrained { Bytes2::validate_inputs(&__v_616, &__v_640)?; Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record)? }; + let __v_653: G = if unconstrained { Bytes2::validate_inputs(&__v_617, &__v_641)?; Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record)? }; let __u32_sum: u128 = u128::from(((__v_620.as_canonical_u64() << 0) | (__v_621.as_canonical_u64() << 8) | (__v_622.as_canonical_u64() << 16) | (__v_623.as_canonical_u64() << 24))) + u128::from(((__v_651.as_canonical_u64() << 0) | (__v_652.as_canonical_u64() << 8) | (__v_653.as_canonical_u64() << 16) | (__v_650.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_654: G = G::from_u8(__u32_bytes[0]); @@ -6576,22 +6652,22 @@ fn aiur_fn_74( let __v_656: G = G::from_u8(__u32_bytes[2]); let __v_657: G = G::from_u8(__u32_bytes[3]); let __v_658: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_654; let __vj = __v_655; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_656; let __vj = __v_657; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_654; let __vj = __v_655; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_656; let __vj = __v_657; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_659: G = (__v_658 * __v_658); if (__v_659 != __v_658) { return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_658.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_634, &__v_654)?; Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record)? }; let __v_660: G = __b2_out.0; let __v_661: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_635, &__v_655)?; Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record)? }; let __v_662: G = __b2_out.0; let __v_663: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_636, &__v_656)?; Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record)? }; let __v_664: G = __b2_out.0; let __v_665: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_637, &__v_657)?; Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record)? }; let __v_666: G = __b2_out.0; let __v_667: G = __b2_out.1; let __v_668: G = (__v_660 + __v_663); @@ -6599,7 +6675,7 @@ fn aiur_fn_74( let __v_670: G = (__v_664 + __v_667); let __v_671: G = (__v_666 + __v_661); let __ret: [G; OUT_74] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; - record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[74].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -6608,118 +6684,119 @@ const INPUT_SIZE_75: usize = 106; const IN_75: usize = 106; const OUT_75: usize = 32; fn aiur_fn_75( - inp: [G; IN_75], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; + record.checkpoint(75); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); @@ -6743,7 +6820,7 @@ fn aiur_fn_75( let __v_126: G = G::from_u64(0); let __v_127: G = G::from_u64(0); let __v_128: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -6777,7 +6854,7 @@ fn aiur_fn_75( let __v_159: G = __r_arr[30]; let __v_160: G = __r_arr[31]; let __ret: [G; OUT_75] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[75].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -6786,177 +6863,178 @@ const INPUT_SIZE_76: usize = 129; const IN_76: usize = 129; const OUT_76: usize = 32; fn aiur_fn_76( - inp: [G; IN_76], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; - let __v_106: G = inp[106]; - let __v_107: G = inp[107]; - let __v_108: G = inp[108]; - let __v_109: G = inp[109]; - let __v_110: G = inp[110]; - let __v_111: G = inp[111]; - let __v_112: G = inp[112]; - let __v_113: G = inp[113]; - let __v_114: G = inp[114]; - let __v_115: G = inp[115]; - let __v_116: G = inp[116]; - let __v_117: G = inp[117]; - let __v_118: G = inp[118]; - let __v_119: G = inp[119]; - let __v_120: G = inp[120]; - let __v_121: G = inp[121]; - let __v_122: G = inp[122]; - let __v_123: G = inp[123]; - let __v_124: G = inp[124]; - let __v_125: G = inp[125]; - let __v_126: G = inp[126]; - let __v_127: G = inp[127]; - let __v_128: G = inp[128]; + record.checkpoint(76); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; + let __v_106: G = inp.values()[106]; + let __v_107: G = inp.values()[107]; + let __v_108: G = inp.values()[108]; + let __v_109: G = inp.values()[109]; + let __v_110: G = inp.values()[110]; + let __v_111: G = inp.values()[111]; + let __v_112: G = inp.values()[112]; + let __v_113: G = inp.values()[113]; + let __v_114: G = inp.values()[114]; + let __v_115: G = inp.values()[115]; + let __v_116: G = inp.values()[116]; + let __v_117: G = inp.values()[117]; + let __v_118: G = inp.values()[118]; + let __v_119: G = inp.values()[119]; + let __v_120: G = inp.values()[120]; + let __v_121: G = inp.values()[121]; + let __v_122: G = inp.values()[122]; + let __v_123: G = inp.values()[123]; + let __v_124: G = inp.values()[124]; + let __v_125: G = inp.values()[125]; + let __v_126: G = inp.values()[126]; + let __v_127: G = inp.values()[127]; + let __v_128: G = inp.values()[128]; match __v_0.as_canonical_u64() { 7u64 => { - let __v_129: G = if unconstrained { Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record) }; - let __v_130: G = if unconstrained { Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record) }; - let __v_131: G = if unconstrained { Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record) }; - let __v_132: G = if unconstrained { Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record) }; - let __v_133: G = if unconstrained { Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record) }; - let __v_134: G = if unconstrained { Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record) }; - let __v_135: G = if unconstrained { Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record) }; - let __v_136: G = if unconstrained { Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record) }; - let __v_137: G = if unconstrained { Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record) }; - let __v_138: G = if unconstrained { Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record) }; - let __v_139: G = if unconstrained { Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record) }; - let __v_140: G = if unconstrained { Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record) }; - let __v_141: G = if unconstrained { Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record) }; - let __v_144: G = if unconstrained { Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record) }; - let __v_145: G = if unconstrained { Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record) }; - let __v_146: G = if unconstrained { Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record) }; - let __v_147: G = if unconstrained { Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record) }; - let __v_148: G = if unconstrained { Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record) }; - let __v_149: G = if unconstrained { Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record) }; - let __v_150: G = if unconstrained { Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record) }; - let __v_151: G = if unconstrained { Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record) }; - let __v_152: G = if unconstrained { Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record) }; - let __v_153: G = if unconstrained { Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record) }; - let __v_154: G = if unconstrained { Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record) }; - let __v_155: G = if unconstrained { Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record) }; - let __v_156: G = if unconstrained { Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record) }; - let __v_157: G = if unconstrained { Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record) }; - let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) }; - let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) }; - let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) }; + let __v_129: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_33)?; Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record)? }; + let __v_130: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_34)?; Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record)? }; + let __v_131: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_35)?; Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record)? }; + let __v_132: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_36)?; Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record)? }; + let __v_133: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_37)?; Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record)? }; + let __v_134: G = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_38)?; Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record)? }; + let __v_135: G = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_39)?; Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record)? }; + let __v_136: G = if unconstrained { Bytes2::validate_inputs(&__v_8, &__v_40)?; Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record)? }; + let __v_137: G = if unconstrained { Bytes2::validate_inputs(&__v_9, &__v_41)?; Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record)? }; + let __v_138: G = if unconstrained { Bytes2::validate_inputs(&__v_10, &__v_42)?; Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record)? }; + let __v_139: G = if unconstrained { Bytes2::validate_inputs(&__v_11, &__v_43)?; Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record)? }; + let __v_140: G = if unconstrained { Bytes2::validate_inputs(&__v_12, &__v_44)?; Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record)? }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_13, &__v_45)?; Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_14, &__v_46)?; Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_15, &__v_47)?; Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record)? }; + let __v_144: G = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_48)?; Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record)? }; + let __v_145: G = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_49)?; Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record)? }; + let __v_146: G = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_50)?; Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record)? }; + let __v_147: G = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_51)?; Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record)? }; + let __v_148: G = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_52)?; Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record)? }; + let __v_149: G = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_53)?; Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record)? }; + let __v_150: G = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_54)?; Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record)? }; + let __v_151: G = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_55)?; Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record)? }; + let __v_152: G = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_56)?; Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record)? }; + let __v_153: G = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_57)?; Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record)? }; + let __v_154: G = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_58)?; Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record)? }; + let __v_155: G = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_59)?; Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record)? }; + let __v_156: G = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_60)?; Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record)? }; + let __v_157: G = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_61)?; Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record)? }; + let __v_158: G = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_62)?; Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record)? }; + let __v_159: G = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_63)?; Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record)? }; + let __v_160: G = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_64)?; Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record)? }; let __ret: [G; OUT_76] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[76].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -6967,8 +7045,8 @@ fn aiur_fn_76( let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_129; let __vj = __v_130; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_131; let __vj = __v_132; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); @@ -6979,10 +7057,10 @@ fn aiur_fn_76( if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) }; - let __v_144: G = if unconstrained { Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record) }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_49, &__v_129)?; Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_50, &__v_130)?; Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_51, &__v_131)?; Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record)? }; + let __v_144: G = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_132)?; Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record)? }; let __u32_sum: u128 = u128::from(((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8) | (__v_35.as_canonical_u64() << 16) | (__v_36.as_canonical_u64() << 24))) + u128::from(((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8) | (__v_141.as_canonical_u64() << 16) | (__v_142.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); @@ -6990,22 +7068,22 @@ fn aiur_fn_76( let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_145; let __vj = __v_146; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_147; let __vj = __v_148; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_145)?; Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record)? }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_146)?; Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record)? }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_147)?; Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record)? }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_148)?; Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record)? }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); @@ -7019,8 +7097,8 @@ fn aiur_fn_76( let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_163; let __vj = __v_164; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_165; let __vj = __v_166; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_168: G = G::from_u64(1); let __v_169: G = (__v_167 - __v_168); let __v_170: G = G::from_u64(2); @@ -7031,10 +7109,10 @@ fn aiur_fn_76( if (__v_173 != __v_174) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_174.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) }; - let __v_176: G = if unconstrained { Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record) }; - let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) }; - let __v_178: G = if unconstrained { Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record) }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_143, &__v_163)?; Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record)? }; + let __v_176: G = if unconstrained { Bytes2::validate_inputs(&__v_144, &__v_164)?; Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record)? }; + let __v_177: G = if unconstrained { Bytes2::validate_inputs(&__v_141, &__v_165)?; Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record)? }; + let __v_178: G = if unconstrained { Bytes2::validate_inputs(&__v_142, &__v_166)?; Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record)? }; let __u32_sum: u128 = u128::from(((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8) | (__v_147.as_canonical_u64() << 16) | (__v_148.as_canonical_u64() << 24))) + u128::from(((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8) | (__v_178.as_canonical_u64() << 16) | (__v_175.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_179: G = G::from_u8(__u32_bytes[0]); @@ -7042,22 +7120,22 @@ fn aiur_fn_76( let __v_181: G = G::from_u8(__u32_bytes[2]); let __v_182: G = G::from_u8(__u32_bytes[3]); let __v_183: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_179; let __vj = __v_180; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_181; let __vj = __v_182; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_179; let __vj = __v_180; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_181; let __vj = __v_182; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_184: G = (__v_183 * __v_183); if (__v_184 != __v_183) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_159, &__v_179)?; Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record)? }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_160, &__v_180)?; Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record)? }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_161, &__v_181)?; Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record)? }; let __v_189: G = __b2_out.0; let __v_190: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_162, &__v_182)?; Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record)? }; let __v_191: G = __b2_out.0; let __v_192: G = __b2_out.1; let __v_193: G = (__v_185 + __v_188); @@ -7071,8 +7149,8 @@ fn aiur_fn_76( let __v_199: G = G::from_u8(__u32_bytes[2]); let __v_200: G = G::from_u8(__u32_bytes[3]); let __v_201: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_197; let __vj = __v_198; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_199; let __vj = __v_200; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_197; let __vj = __v_198; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_199; let __vj = __v_200; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_202: G = G::from_u64(1); let __v_203: G = (__v_201 - __v_202); let __v_204: G = G::from_u64(2); @@ -7083,10 +7161,10 @@ fn aiur_fn_76( if (__v_207 != __v_208) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_208.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) }; - let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) }; - let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) }; - let __v_212: G = if unconstrained { Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record) }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_53, &__v_197)?; Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record)? }; + let __v_210: G = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_198)?; Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record)? }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_199)?; Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record)? }; + let __v_212: G = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_200)?; Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record)? }; let __u32_sum: u128 = u128::from(((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8) | (__v_39.as_canonical_u64() << 16) | (__v_40.as_canonical_u64() << 24))) + u128::from(((__v_211.as_canonical_u64() << 0) | (__v_212.as_canonical_u64() << 8) | (__v_209.as_canonical_u64() << 16) | (__v_210.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_213: G = G::from_u8(__u32_bytes[0]); @@ -7094,22 +7172,22 @@ fn aiur_fn_76( let __v_215: G = G::from_u8(__u32_bytes[2]); let __v_216: G = G::from_u8(__u32_bytes[3]); let __v_217: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_213; let __vj = __v_214; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_215; let __vj = __v_216; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_213; let __vj = __v_214; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_215; let __vj = __v_216; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_218: G = (__v_217 * __v_217); if (__v_218 != __v_217) { return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_217.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_213)?; Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record)? }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_214)?; Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record)? }; let __v_221: G = __b2_out.0; let __v_222: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_215)?; Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record)? }; let __v_223: G = __b2_out.0; let __v_224: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_216)?; Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record)? }; let __v_225: G = __b2_out.0; let __v_226: G = __b2_out.1; let __v_227: G = (__v_221 + __v_224); @@ -7123,8 +7201,8 @@ fn aiur_fn_76( let __v_233: G = G::from_u8(__u32_bytes[2]); let __v_234: G = G::from_u8(__u32_bytes[3]); let __v_235: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_231; let __vj = __v_232; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_233; let __vj = __v_234; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_236: G = G::from_u64(1); let __v_237: G = (__v_235 - __v_236); let __v_238: G = G::from_u64(2); @@ -7135,10 +7213,10 @@ fn aiur_fn_76( if (__v_241 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) }; - let __v_244: G = if unconstrained { Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record) }; - let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) }; - let __v_246: G = if unconstrained { Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record) }; + let __v_243: G = if unconstrained { Bytes2::validate_inputs(&__v_211, &__v_231)?; Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record)? }; + let __v_244: G = if unconstrained { Bytes2::validate_inputs(&__v_212, &__v_232)?; Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record)? }; + let __v_245: G = if unconstrained { Bytes2::validate_inputs(&__v_209, &__v_233)?; Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record)? }; + let __v_246: G = if unconstrained { Bytes2::validate_inputs(&__v_210, &__v_234)?; Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record)? }; let __u32_sum: u128 = u128::from(((__v_213.as_canonical_u64() << 0) | (__v_214.as_canonical_u64() << 8) | (__v_215.as_canonical_u64() << 16) | (__v_216.as_canonical_u64() << 24))) + u128::from(((__v_244.as_canonical_u64() << 0) | (__v_245.as_canonical_u64() << 8) | (__v_246.as_canonical_u64() << 16) | (__v_243.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_247: G = G::from_u8(__u32_bytes[0]); @@ -7146,22 +7224,22 @@ fn aiur_fn_76( let __v_249: G = G::from_u8(__u32_bytes[2]); let __v_250: G = G::from_u8(__u32_bytes[3]); let __v_251: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_247; let __vj = __v_248; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_249; let __vj = __v_250; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_247; let __vj = __v_248; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_249; let __vj = __v_250; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_252: G = (__v_251 * __v_251); if (__v_252 != __v_251) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_227, &__v_247)?; Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record)? }; let __v_253: G = __b2_out.0; let __v_254: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_228, &__v_248)?; Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record)? }; let __v_255: G = __b2_out.0; let __v_256: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_229, &__v_249)?; Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record)? }; let __v_257: G = __b2_out.0; let __v_258: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_230, &__v_250)?; Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record)? }; let __v_259: G = __b2_out.0; let __v_260: G = __b2_out.1; let __v_261: G = (__v_253 + __v_256); @@ -7175,8 +7253,8 @@ fn aiur_fn_76( let __v_267: G = G::from_u8(__u32_bytes[2]); let __v_268: G = G::from_u8(__u32_bytes[3]); let __v_269: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_265; let __vj = __v_266; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_267; let __vj = __v_268; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_270: G = G::from_u64(1); let __v_271: G = (__v_269 - __v_270); let __v_272: G = G::from_u64(2); @@ -7187,10 +7265,10 @@ fn aiur_fn_76( if (__v_275 != __v_276) { return Err(ExecError::AssertEqMismatch { lhs: __v_275.as_canonical_u64(), rhs: __v_276.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) }; - let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) }; - let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) }; - let __v_280: G = if unconstrained { Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record) }; + let __v_277: G = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_265)?; Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record)? }; + let __v_278: G = if unconstrained { Bytes2::validate_inputs(&__v_58, &__v_266)?; Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record)? }; + let __v_279: G = if unconstrained { Bytes2::validate_inputs(&__v_59, &__v_267)?; Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record)? }; + let __v_280: G = if unconstrained { Bytes2::validate_inputs(&__v_60, &__v_268)?; Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record)? }; let __u32_sum: u128 = u128::from(((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8) | (__v_43.as_canonical_u64() << 16) | (__v_44.as_canonical_u64() << 24))) + u128::from(((__v_279.as_canonical_u64() << 0) | (__v_280.as_canonical_u64() << 8) | (__v_277.as_canonical_u64() << 16) | (__v_278.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_281: G = G::from_u8(__u32_bytes[0]); @@ -7198,22 +7276,22 @@ fn aiur_fn_76( let __v_283: G = G::from_u8(__u32_bytes[2]); let __v_284: G = G::from_u8(__u32_bytes[3]); let __v_285: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_281; let __vj = __v_282; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_283; let __vj = __v_284; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_281; let __vj = __v_282; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_283; let __vj = __v_284; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_286: G = (__v_285 * __v_285); if (__v_286 != __v_285) { return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_285.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_281)?; Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record)? }; let __v_287: G = __b2_out.0; let __v_288: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_282)?; Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record)? }; let __v_289: G = __b2_out.0; let __v_290: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_283)?; Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record)? }; let __v_291: G = __b2_out.0; let __v_292: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_284)?; Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record)? }; let __v_293: G = __b2_out.0; let __v_294: G = __b2_out.1; let __v_295: G = (__v_289 + __v_292); @@ -7227,8 +7305,8 @@ fn aiur_fn_76( let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_299; let __vj = __v_300; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_301; let __vj = __v_302; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_304: G = G::from_u64(1); let __v_305: G = (__v_303 - __v_304); let __v_306: G = G::from_u64(2); @@ -7239,10 +7317,10 @@ fn aiur_fn_76( if (__v_309 != __v_310) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_310.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) }; - let __v_312: G = if unconstrained { Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record) }; - let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) }; - let __v_314: G = if unconstrained { Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record) }; + let __v_311: G = if unconstrained { Bytes2::validate_inputs(&__v_279, &__v_299)?; Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record)? }; + let __v_312: G = if unconstrained { Bytes2::validate_inputs(&__v_280, &__v_300)?; Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record)? }; + let __v_313: G = if unconstrained { Bytes2::validate_inputs(&__v_277, &__v_301)?; Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record)? }; + let __v_314: G = if unconstrained { Bytes2::validate_inputs(&__v_278, &__v_302)?; Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record)? }; let __u32_sum: u128 = u128::from(((__v_281.as_canonical_u64() << 0) | (__v_282.as_canonical_u64() << 8) | (__v_283.as_canonical_u64() << 16) | (__v_284.as_canonical_u64() << 24))) + u128::from(((__v_312.as_canonical_u64() << 0) | (__v_313.as_canonical_u64() << 8) | (__v_314.as_canonical_u64() << 16) | (__v_311.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_315: G = G::from_u8(__u32_bytes[0]); @@ -7250,22 +7328,22 @@ fn aiur_fn_76( let __v_317: G = G::from_u8(__u32_bytes[2]); let __v_318: G = G::from_u8(__u32_bytes[3]); let __v_319: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_315; let __vj = __v_316; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_315; let __vj = __v_316; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_317; let __vj = __v_318; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_320: G = (__v_319 * __v_319); if (__v_320 != __v_319) { return Err(ExecError::AssertEqMismatch { lhs: __v_320.as_canonical_u64(), rhs: __v_319.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_295, &__v_315)?; Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record)? }; let __v_321: G = __b2_out.0; let __v_322: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_296, &__v_316)?; Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record)? }; let __v_323: G = __b2_out.0; let __v_324: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_297, &__v_317)?; Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record)? }; let __v_325: G = __b2_out.0; let __v_326: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_298, &__v_318)?; Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record)? }; let __v_327: G = __b2_out.0; let __v_328: G = __b2_out.1; let __v_329: G = (__v_321 + __v_324); @@ -7279,8 +7357,8 @@ fn aiur_fn_76( let __v_335: G = G::from_u8(__u32_bytes[2]); let __v_336: G = G::from_u8(__u32_bytes[3]); let __v_337: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_335; let __vj = __v_336; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_333; let __vj = __v_334; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_335; let __vj = __v_336; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_338: G = G::from_u64(1); let __v_339: G = (__v_337 - __v_338); let __v_340: G = G::from_u64(2); @@ -7291,10 +7369,10 @@ fn aiur_fn_76( if (__v_343 != __v_344) { return Err(ExecError::AssertEqMismatch { lhs: __v_343.as_canonical_u64(), rhs: __v_344.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) }; - let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) }; - let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) }; - let __v_348: G = if unconstrained { Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record) }; + let __v_345: G = if unconstrained { Bytes2::validate_inputs(&__v_61, &__v_333)?; Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record)? }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_62, &__v_334)?; Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record)? }; + let __v_347: G = if unconstrained { Bytes2::validate_inputs(&__v_63, &__v_335)?; Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record)? }; + let __v_348: G = if unconstrained { Bytes2::validate_inputs(&__v_64, &__v_336)?; Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record)? }; let __u32_sum: u128 = u128::from(((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8) | (__v_47.as_canonical_u64() << 16) | (__v_48.as_canonical_u64() << 24))) + u128::from(((__v_347.as_canonical_u64() << 0) | (__v_348.as_canonical_u64() << 8) | (__v_345.as_canonical_u64() << 16) | (__v_346.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); @@ -7302,22 +7380,22 @@ fn aiur_fn_76( let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_349; let __vj = __v_350; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_351; let __vj = __v_352; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_354: G = (__v_353 * __v_353); if (__v_354 != __v_353) { return Err(ExecError::AssertEqMismatch { lhs: __v_354.as_canonical_u64(), rhs: __v_353.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_349)?; Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record)? }; let __v_355: G = __b2_out.0; let __v_356: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_350)?; Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record)? }; let __v_357: G = __b2_out.0; let __v_358: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_351)?; Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record)? }; let __v_359: G = __b2_out.0; let __v_360: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_352)?; Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record)? }; let __v_361: G = __b2_out.0; let __v_362: G = __b2_out.1; let __v_363: G = (__v_357 + __v_360); @@ -7331,8 +7409,8 @@ fn aiur_fn_76( let __v_369: G = G::from_u8(__u32_bytes[2]); let __v_370: G = G::from_u8(__u32_bytes[3]); let __v_371: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_367; let __vj = __v_368; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_369; let __vj = __v_370; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_367; let __vj = __v_368; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_369; let __vj = __v_370; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_372: G = G::from_u64(1); let __v_373: G = (__v_371 - __v_372); let __v_374: G = G::from_u64(2); @@ -7343,10 +7421,10 @@ fn aiur_fn_76( if (__v_377 != __v_378) { return Err(ExecError::AssertEqMismatch { lhs: __v_377.as_canonical_u64(), rhs: __v_378.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) }; - let __v_380: G = if unconstrained { Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record) }; - let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) }; - let __v_382: G = if unconstrained { Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record) }; + let __v_379: G = if unconstrained { Bytes2::validate_inputs(&__v_347, &__v_367)?; Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record)? }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_348, &__v_368)?; Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record)? }; + let __v_381: G = if unconstrained { Bytes2::validate_inputs(&__v_345, &__v_369)?; Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record)? }; + let __v_382: G = if unconstrained { Bytes2::validate_inputs(&__v_346, &__v_370)?; Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record)? }; let __u32_sum: u128 = u128::from(((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8) | (__v_351.as_canonical_u64() << 16) | (__v_352.as_canonical_u64() << 24))) + u128::from(((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8) | (__v_382.as_canonical_u64() << 16) | (__v_379.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_383: G = G::from_u8(__u32_bytes[0]); @@ -7354,22 +7432,22 @@ fn aiur_fn_76( let __v_385: G = G::from_u8(__u32_bytes[2]); let __v_386: G = G::from_u8(__u32_bytes[3]); let __v_387: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_383; let __vj = __v_384; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_385; let __vj = __v_386; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_383; let __vj = __v_384; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_385; let __vj = __v_386; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_388: G = (__v_387 * __v_387); if (__v_388 != __v_387) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_363, &__v_383)?; Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record)? }; let __v_389: G = __b2_out.0; let __v_390: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_364, &__v_384)?; Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record)? }; let __v_391: G = __b2_out.0; let __v_392: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_365, &__v_385)?; Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record)? }; let __v_393: G = __b2_out.0; let __v_394: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_366, &__v_386)?; Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record)? }; let __v_395: G = __b2_out.0; let __v_396: G = __b2_out.1; let __v_397: G = (__v_389 + __v_392); @@ -7383,8 +7461,8 @@ fn aiur_fn_76( let __v_403: G = G::from_u8(__u32_bytes[2]); let __v_404: G = G::from_u8(__u32_bytes[3]); let __v_405: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_401; let __vj = __v_402; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_403; let __vj = __v_404; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_401; let __vj = __v_402; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_403; let __vj = __v_404; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_406: G = G::from_u64(1); let __v_407: G = (__v_405 - __v_406); let __v_408: G = G::from_u64(2); @@ -7395,10 +7473,10 @@ fn aiur_fn_76( if (__v_411 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) }; - let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) }; - let __v_415: G = if unconstrained { Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record) }; - let __v_416: G = if unconstrained { Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record) }; + let __v_413: G = if unconstrained { Bytes2::validate_inputs(&__v_380, &__v_401)?; Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record)? }; + let __v_414: G = if unconstrained { Bytes2::validate_inputs(&__v_381, &__v_402)?; Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record)? }; + let __v_415: G = if unconstrained { Bytes2::validate_inputs(&__v_382, &__v_403)?; Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record)? }; + let __v_416: G = if unconstrained { Bytes2::validate_inputs(&__v_379, &__v_404)?; Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record)? }; let __u32_sum: u128 = u128::from(((__v_315.as_canonical_u64() << 0) | (__v_316.as_canonical_u64() << 8) | (__v_317.as_canonical_u64() << 16) | (__v_318.as_canonical_u64() << 24))) + u128::from(((__v_415.as_canonical_u64() << 0) | (__v_416.as_canonical_u64() << 8) | (__v_413.as_canonical_u64() << 16) | (__v_414.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_417: G = G::from_u8(__u32_bytes[0]); @@ -7406,22 +7484,22 @@ fn aiur_fn_76( let __v_419: G = G::from_u8(__u32_bytes[2]); let __v_420: G = G::from_u8(__u32_bytes[3]); let __v_421: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_417; let __vj = __v_418; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_419; let __vj = __v_420; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_417; let __vj = __v_418; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_419; let __vj = __v_420; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_422: G = (__v_421 * __v_421); if (__v_422 != __v_421) { return Err(ExecError::AssertEqMismatch { lhs: __v_422.as_canonical_u64(), rhs: __v_421.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_261, &__v_417)?; Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record)? }; let __v_423: G = __b2_out.0; let __v_424: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_418)?; Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record)? }; let __v_425: G = __b2_out.0; let __v_426: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_419)?; Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record)? }; let __v_427: G = __b2_out.0; let __v_428: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_264, &__v_420)?; Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record)? }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __v_431: G = (__v_425 + __v_428); @@ -7435,8 +7513,8 @@ fn aiur_fn_76( let __v_437: G = G::from_u8(__u32_bytes[2]); let __v_438: G = G::from_u8(__u32_bytes[3]); let __v_439: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_435; let __vj = __v_436; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_437; let __vj = __v_438; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_435; let __vj = __v_436; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_437; let __vj = __v_438; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_440: G = G::from_u64(1); let __v_441: G = (__v_439 - __v_440); let __v_442: G = G::from_u64(2); @@ -7447,10 +7525,10 @@ fn aiur_fn_76( if (__v_445 != __v_446) { return Err(ExecError::AssertEqMismatch { lhs: __v_445.as_canonical_u64(), rhs: __v_446.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) }; - let __v_448: G = if unconstrained { Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record) }; - let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) }; - let __v_450: G = if unconstrained { Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record) }; + let __v_447: G = if unconstrained { Bytes2::validate_inputs(&__v_415, &__v_435)?; Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record)? }; + let __v_448: G = if unconstrained { Bytes2::validate_inputs(&__v_416, &__v_436)?; Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record)? }; + let __v_449: G = if unconstrained { Bytes2::validate_inputs(&__v_413, &__v_437)?; Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record)? }; + let __v_450: G = if unconstrained { Bytes2::validate_inputs(&__v_414, &__v_438)?; Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record)? }; let __u32_sum: u128 = u128::from(((__v_417.as_canonical_u64() << 0) | (__v_418.as_canonical_u64() << 8) | (__v_419.as_canonical_u64() << 16) | (__v_420.as_canonical_u64() << 24))) + u128::from(((__v_448.as_canonical_u64() << 0) | (__v_449.as_canonical_u64() << 8) | (__v_450.as_canonical_u64() << 16) | (__v_447.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_451: G = G::from_u8(__u32_bytes[0]); @@ -7458,22 +7536,22 @@ fn aiur_fn_76( let __v_453: G = G::from_u8(__u32_bytes[2]); let __v_454: G = G::from_u8(__u32_bytes[3]); let __v_455: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_451; let __vj = __v_452; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_453; let __vj = __v_454; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_451; let __vj = __v_452; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_453; let __vj = __v_454; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_456: G = (__v_455 * __v_455); if (__v_456 != __v_455) { return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_431, &__v_451)?; Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record)? }; let __v_457: G = __b2_out.0; let __v_458: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_432, &__v_452)?; Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record)? }; let __v_459: G = __b2_out.0; let __v_460: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_433, &__v_453)?; Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record)? }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_434, &__v_454)?; Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record)? }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __v_465: G = (__v_457 + __v_460); @@ -7487,8 +7565,8 @@ fn aiur_fn_76( let __v_471: G = G::from_u8(__u32_bytes[2]); let __v_472: G = G::from_u8(__u32_bytes[3]); let __v_473: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_469; let __vj = __v_470; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_471; let __vj = __v_472; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_469; let __vj = __v_470; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_471; let __vj = __v_472; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_474: G = G::from_u64(1); let __v_475: G = (__v_473 - __v_474); let __v_476: G = G::from_u64(2); @@ -7499,10 +7577,10 @@ fn aiur_fn_76( if (__v_479 != __v_480) { return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) }; - let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) }; - let __v_483: G = if unconstrained { Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record) }; - let __v_484: G = if unconstrained { Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record) }; + let __v_481: G = if unconstrained { Bytes2::validate_inputs(&__v_176, &__v_469)?; Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record)? }; + let __v_482: G = if unconstrained { Bytes2::validate_inputs(&__v_177, &__v_470)?; Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record)? }; + let __v_483: G = if unconstrained { Bytes2::validate_inputs(&__v_178, &__v_471)?; Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record)? }; + let __v_484: G = if unconstrained { Bytes2::validate_inputs(&__v_175, &__v_472)?; Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record)? }; let __u32_sum: u128 = u128::from(((__v_383.as_canonical_u64() << 0) | (__v_384.as_canonical_u64() << 8) | (__v_385.as_canonical_u64() << 16) | (__v_386.as_canonical_u64() << 24))) + u128::from(((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8) | (__v_481.as_canonical_u64() << 16) | (__v_482.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); @@ -7510,22 +7588,22 @@ fn aiur_fn_76( let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_485; let __vj = __v_486; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_487; let __vj = __v_488; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_329, &__v_485)?; Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record)? }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_330, &__v_486)?; Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record)? }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_331, &__v_487)?; Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record)? }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_332, &__v_488)?; Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record)? }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_493 + __v_496); @@ -7539,8 +7617,8 @@ fn aiur_fn_76( let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_503; let __vj = __v_504; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_505; let __vj = __v_506; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_508: G = G::from_u64(1); let __v_509: G = (__v_507 - __v_508); let __v_510: G = G::from_u64(2); @@ -7551,10 +7629,10 @@ fn aiur_fn_76( if (__v_513 != __v_514) { return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) }; - let __v_516: G = if unconstrained { Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record) }; - let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) }; - let __v_518: G = if unconstrained { Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record) }; + let __v_515: G = if unconstrained { Bytes2::validate_inputs(&__v_483, &__v_503)?; Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record)? }; + let __v_516: G = if unconstrained { Bytes2::validate_inputs(&__v_484, &__v_504)?; Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record)? }; + let __v_517: G = if unconstrained { Bytes2::validate_inputs(&__v_481, &__v_505)?; Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record)? }; + let __v_518: G = if unconstrained { Bytes2::validate_inputs(&__v_482, &__v_506)?; Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record)? }; let __u32_sum: u128 = u128::from(((__v_485.as_canonical_u64() << 0) | (__v_486.as_canonical_u64() << 8) | (__v_487.as_canonical_u64() << 16) | (__v_488.as_canonical_u64() << 24))) + u128::from(((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8) | (__v_518.as_canonical_u64() << 16) | (__v_515.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_519: G = G::from_u8(__u32_bytes[0]); @@ -7562,22 +7640,22 @@ fn aiur_fn_76( let __v_521: G = G::from_u8(__u32_bytes[2]); let __v_522: G = G::from_u8(__u32_bytes[3]); let __v_523: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_521; let __vj = __v_522; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_519; let __vj = __v_520; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_521; let __vj = __v_522; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_524: G = (__v_523 * __v_523); if (__v_524 != __v_523) { return Err(ExecError::AssertEqMismatch { lhs: __v_524.as_canonical_u64(), rhs: __v_523.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_499, &__v_519)?; Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record)? }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_500, &__v_520)?; Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record)? }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_501, &__v_521)?; Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record)? }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_502, &__v_522)?; Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record)? }; let __v_531: G = __b2_out.0; let __v_532: G = __b2_out.1; let __v_533: G = (__v_525 + __v_528); @@ -7591,8 +7669,8 @@ fn aiur_fn_76( let __v_539: G = G::from_u8(__u32_bytes[2]); let __v_540: G = G::from_u8(__u32_bytes[3]); let __v_541: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_539; let __vj = __v_540; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_537; let __vj = __v_538; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_539; let __vj = __v_540; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_542: G = G::from_u64(1); let __v_543: G = (__v_541 - __v_542); let __v_544: G = G::from_u64(2); @@ -7603,10 +7681,10 @@ fn aiur_fn_76( if (__v_547 != __v_548) { return Err(ExecError::AssertEqMismatch { lhs: __v_547.as_canonical_u64(), rhs: __v_548.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) }; - let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) }; - let __v_551: G = if unconstrained { Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record) }; - let __v_552: G = if unconstrained { Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record) }; + let __v_549: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_537)?; Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record)? }; + let __v_550: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_538)?; Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record)? }; + let __v_551: G = if unconstrained { Bytes2::validate_inputs(&__v_246, &__v_539)?; Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record)? }; + let __v_552: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_540)?; Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record)? }; let __u32_sum: u128 = u128::from(((__v_179.as_canonical_u64() << 0) | (__v_180.as_canonical_u64() << 8) | (__v_181.as_canonical_u64() << 16) | (__v_182.as_canonical_u64() << 24))) + u128::from(((__v_551.as_canonical_u64() << 0) | (__v_552.as_canonical_u64() << 8) | (__v_549.as_canonical_u64() << 16) | (__v_550.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_553: G = G::from_u8(__u32_bytes[0]); @@ -7614,22 +7692,22 @@ fn aiur_fn_76( let __v_555: G = G::from_u8(__u32_bytes[2]); let __v_556: G = G::from_u8(__u32_bytes[3]); let __v_557: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_553; let __vj = __v_554; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_555; let __vj = __v_556; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_553; let __vj = __v_554; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_555; let __vj = __v_556; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_558: G = (__v_557 * __v_557); if (__v_558 != __v_557) { return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_553)?; Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record)? }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_398, &__v_554)?; Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record)? }; let __v_561: G = __b2_out.0; let __v_562: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_399, &__v_555)?; Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record)? }; let __v_563: G = __b2_out.0; let __v_564: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_400, &__v_556)?; Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record)? }; let __v_565: G = __b2_out.0; let __v_566: G = __b2_out.1; let __v_567: G = (__v_561 + __v_564); @@ -7643,8 +7721,8 @@ fn aiur_fn_76( let __v_573: G = G::from_u8(__u32_bytes[2]); let __v_574: G = G::from_u8(__u32_bytes[3]); let __v_575: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_571; let __vj = __v_572; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_573; let __vj = __v_574; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_571; let __vj = __v_572; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_573; let __vj = __v_574; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_576: G = G::from_u64(1); let __v_577: G = (__v_575 - __v_576); let __v_578: G = G::from_u64(2); @@ -7655,10 +7733,10 @@ fn aiur_fn_76( if (__v_581 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_581.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) }; - let __v_584: G = if unconstrained { Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record) }; - let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) }; - let __v_586: G = if unconstrained { Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record) }; + let __v_583: G = if unconstrained { Bytes2::validate_inputs(&__v_551, &__v_571)?; Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record)? }; + let __v_584: G = if unconstrained { Bytes2::validate_inputs(&__v_552, &__v_572)?; Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record)? }; + let __v_585: G = if unconstrained { Bytes2::validate_inputs(&__v_549, &__v_573)?; Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record)? }; + let __v_586: G = if unconstrained { Bytes2::validate_inputs(&__v_550, &__v_574)?; Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record)? }; let __u32_sum: u128 = u128::from(((__v_553.as_canonical_u64() << 0) | (__v_554.as_canonical_u64() << 8) | (__v_555.as_canonical_u64() << 16) | (__v_556.as_canonical_u64() << 24))) + u128::from(((__v_584.as_canonical_u64() << 0) | (__v_585.as_canonical_u64() << 8) | (__v_586.as_canonical_u64() << 16) | (__v_583.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_587: G = G::from_u8(__u32_bytes[0]); @@ -7666,22 +7744,22 @@ fn aiur_fn_76( let __v_589: G = G::from_u8(__u32_bytes[2]); let __v_590: G = G::from_u8(__u32_bytes[3]); let __v_591: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_587; let __vj = __v_588; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_589; let __vj = __v_590; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_587; let __vj = __v_588; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_589; let __vj = __v_590; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_592: G = (__v_591 * __v_591); if (__v_592 != __v_591) { return Err(ExecError::AssertEqMismatch { lhs: __v_592.as_canonical_u64(), rhs: __v_591.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_567, &__v_587)?; Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record)? }; let __v_593: G = __b2_out.0; let __v_594: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_568, &__v_588)?; Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record)? }; let __v_595: G = __b2_out.0; let __v_596: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_569, &__v_589)?; Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record)? }; let __v_597: G = __b2_out.0; let __v_598: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_570, &__v_590)?; Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record)? }; let __v_599: G = __b2_out.0; let __v_600: G = __b2_out.1; let __v_601: G = (__v_593 + __v_596); @@ -7695,8 +7773,8 @@ fn aiur_fn_76( let __v_607: G = G::from_u8(__u32_bytes[2]); let __v_608: G = G::from_u8(__u32_bytes[3]); let __v_609: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_605; let __vj = __v_606; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_607; let __vj = __v_608; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_605; let __vj = __v_606; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_607; let __vj = __v_608; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_610: G = G::from_u64(1); let __v_611: G = (__v_609 - __v_610); let __v_612: G = G::from_u64(2); @@ -7707,10 +7785,10 @@ fn aiur_fn_76( if (__v_615 != __v_616) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_616.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) }; - let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) }; - let __v_619: G = if unconstrained { Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record) }; - let __v_620: G = if unconstrained { Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record) }; + let __v_617: G = if unconstrained { Bytes2::validate_inputs(&__v_312, &__v_605)?; Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record)? }; + let __v_618: G = if unconstrained { Bytes2::validate_inputs(&__v_313, &__v_606)?; Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record)? }; + let __v_619: G = if unconstrained { Bytes2::validate_inputs(&__v_314, &__v_607)?; Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record)? }; + let __v_620: G = if unconstrained { Bytes2::validate_inputs(&__v_311, &__v_608)?; Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record)? }; let __u32_sum: u128 = u128::from(((__v_247.as_canonical_u64() << 0) | (__v_248.as_canonical_u64() << 8) | (__v_249.as_canonical_u64() << 16) | (__v_250.as_canonical_u64() << 24))) + u128::from(((__v_619.as_canonical_u64() << 0) | (__v_620.as_canonical_u64() << 8) | (__v_617.as_canonical_u64() << 16) | (__v_618.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_621: G = G::from_u8(__u32_bytes[0]); @@ -7718,22 +7796,22 @@ fn aiur_fn_76( let __v_623: G = G::from_u8(__u32_bytes[2]); let __v_624: G = G::from_u8(__u32_bytes[3]); let __v_625: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_621; let __vj = __v_622; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_623; let __vj = __v_624; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_621; let __vj = __v_622; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_623; let __vj = __v_624; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_626: G = (__v_625 * __v_625); if (__v_626 != __v_625) { return Err(ExecError::AssertEqMismatch { lhs: __v_626.as_canonical_u64(), rhs: __v_625.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_193, &__v_621)?; Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record)? }; let __v_627: G = __b2_out.0; let __v_628: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_194, &__v_622)?; Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record)? }; let __v_629: G = __b2_out.0; let __v_630: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_195, &__v_623)?; Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record)? }; let __v_631: G = __b2_out.0; let __v_632: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_196, &__v_624)?; Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record)? }; let __v_633: G = __b2_out.0; let __v_634: G = __b2_out.1; let __v_635: G = (__v_629 + __v_632); @@ -7747,8 +7825,8 @@ fn aiur_fn_76( let __v_641: G = G::from_u8(__u32_bytes[2]); let __v_642: G = G::from_u8(__u32_bytes[3]); let __v_643: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_639; let __vj = __v_640; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_641; let __vj = __v_642; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_639; let __vj = __v_640; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_641; let __vj = __v_642; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_644: G = G::from_u64(1); let __v_645: G = (__v_643 - __v_644); let __v_646: G = G::from_u64(2); @@ -7759,10 +7837,10 @@ fn aiur_fn_76( if (__v_649 != __v_650) { return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) }; - let __v_652: G = if unconstrained { Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record) }; - let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) }; - let __v_654: G = if unconstrained { Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record) }; + let __v_651: G = if unconstrained { Bytes2::validate_inputs(&__v_619, &__v_639)?; Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record)? }; + let __v_652: G = if unconstrained { Bytes2::validate_inputs(&__v_620, &__v_640)?; Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record)? }; + let __v_653: G = if unconstrained { Bytes2::validate_inputs(&__v_617, &__v_641)?; Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record)? }; + let __v_654: G = if unconstrained { Bytes2::validate_inputs(&__v_618, &__v_642)?; Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record)? }; let __u32_sum: u128 = u128::from(((__v_621.as_canonical_u64() << 0) | (__v_622.as_canonical_u64() << 8) | (__v_623.as_canonical_u64() << 16) | (__v_624.as_canonical_u64() << 24))) + u128::from(((__v_652.as_canonical_u64() << 0) | (__v_653.as_canonical_u64() << 8) | (__v_654.as_canonical_u64() << 16) | (__v_651.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_655: G = G::from_u8(__u32_bytes[0]); @@ -7770,22 +7848,22 @@ fn aiur_fn_76( let __v_657: G = G::from_u8(__u32_bytes[2]); let __v_658: G = G::from_u8(__u32_bytes[3]); let __v_659: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_655; let __vj = __v_656; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_657; let __vj = __v_658; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_655; let __vj = __v_656; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_657; let __vj = __v_658; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_660: G = (__v_659 * __v_659); if (__v_660 != __v_659) { return Err(ExecError::AssertEqMismatch { lhs: __v_660.as_canonical_u64(), rhs: __v_659.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_635, &__v_655)?; Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record)? }; let __v_661: G = __b2_out.0; let __v_662: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_636, &__v_656)?; Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record)? }; let __v_663: G = __b2_out.0; let __v_664: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_637, &__v_657)?; Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record)? }; let __v_665: G = __b2_out.0; let __v_666: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_638, &__v_658)?; Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record)? }; let __v_667: G = __b2_out.0; let __v_668: G = __b2_out.1; let __v_669: G = (__v_661 + __v_664); @@ -7794,7 +7872,7 @@ fn aiur_fn_76( let __v_672: G = (__v_667 + __v_662); let __v_673: G = G::from_u64(1); let __v_674: G = (__v_0 + __v_673); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -7828,7 +7906,7 @@ fn aiur_fn_76( let __v_705: G = __r_arr[30]; let __v_706: G = __r_arr[31]; let __ret: [G; OUT_76] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; - record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[76].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -7839,21 +7917,22 @@ const INPUT_SIZE_77: usize = 1; const IN_77: usize = 1; const OUT_77: usize = 2; fn aiur_fn_77( - inp: [G; IN_77], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(77); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_77] = [__v_2, __v_3]; - record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[77].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -7867,18 +7946,19 @@ const INPUT_SIZE_78: usize = 1; const IN_78: usize = 1; const OUT_78: usize = 2; fn aiur_fn_78( - inp: [G; IN_78], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(78); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_78] = [__v_1, __v_2]; - record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[78].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7887,24 +7967,25 @@ const INPUT_SIZE_79: usize = 1; const IN_79: usize = 1; const OUT_79: usize = 2; fn aiur_fn_79( - inp: [G; IN_79], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(79); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __ret: [G; OUT_79] = [__v_7, __v_4]; - record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[79].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7913,17 +7994,18 @@ const INPUT_SIZE_80: usize = 1; const IN_80: usize = 1; const OUT_80: usize = 10; fn aiur_fn_80( - inp: [G; IN_80], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(80); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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); @@ -7936,7 +8018,7 @@ fn aiur_fn_80( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4]; - record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[80].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7945,23 +8027,24 @@ const INPUT_SIZE_81: usize = 1; const IN_81: usize = 1; const OUT_81: usize = 10; fn aiur_fn_81( - inp: [G; IN_81], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(81); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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); @@ -7978,7 +8061,7 @@ fn aiur_fn_81( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8]; - record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[81].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7987,39 +8070,40 @@ const INPUT_SIZE_82: usize = 1; const IN_82: usize = 1; const OUT_82: usize = 9; fn aiur_fn_82( - inp: [G; IN_82], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(82); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_82] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8028,14 +8112,15 @@ const INPUT_SIZE_83: usize = 1; const IN_83: usize = 1; const OUT_83: usize = 2; fn aiur_fn_83( - inp: [G; IN_83], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + record.checkpoint(83); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8067,7 +8152,7 @@ fn aiur_fn_83( let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_1 + __v_29); let __ret: [G; OUT_83] = [__v_30, __v_9]; - record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[83].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8076,14 +8161,15 @@ const INPUT_SIZE_84: usize = 1; const IN_84: usize = 1; const OUT_84: usize = 33; fn aiur_fn_84( - inp: [G; IN_84], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + record.checkpoint(84); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8093,7 +8179,7 @@ fn aiur_fn_84( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8103,7 +8189,7 @@ fn aiur_fn_84( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8113,7 +8199,7 @@ fn aiur_fn_84( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8124,7 +8210,7 @@ fn aiur_fn_84( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[84].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8133,25 +8219,26 @@ const INPUT_SIZE_85: usize = 2; const IN_85: usize = 2; const OUT_85: usize = 2; fn aiur_fn_85( - inp: [G; IN_85], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(85); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_4, __v_0]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8161,7 +8248,7 @@ fn aiur_fn_85( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8171,7 +8258,7 @@ fn aiur_fn_85( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8181,7 +8268,7 @@ fn aiur_fn_85( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8193,14 +8280,14 @@ fn aiur_fn_85( let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_44, __v_41]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8211,304 +8298,305 @@ const INPUT_SIZE_86: usize = 2; const IN_86: usize = 2; const OUT_86: usize = 2; fn aiur_fn_86( - inp: [G; IN_86], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(86); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_4, __v_0]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[83].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i)?; } record.function_queries[83].output_at(__i).to_array::() }, _ => aiur_fn_83(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(3); - let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_11, __v_7]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(4); let __v_10: G = G::from_u64(4); - let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_11, __v_7]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(5); - let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_11, __v_7]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(6); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_15, __v_11]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_15, __v_11]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(8); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_15, __v_11]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(9); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 12u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 13u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 14u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(2); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(2); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8521,36 +8609,37 @@ const INPUT_SIZE_87: usize = 2; const IN_87: usize = 2; const OUT_87: usize = 2; fn aiur_fn_87( - inp: [G; IN_87], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(87); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_87] = [__v_4, __v_0]; - record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[87].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_87] = [__v_9, __v_7]; - record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[87].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8561,24 +8650,25 @@ const INPUT_SIZE_88: usize = 1; const IN_88: usize = 1; const OUT_88: usize = 3; fn aiur_fn_88( - inp: [G; IN_88], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + record.checkpoint(88); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, 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]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8587,42 +8677,43 @@ const INPUT_SIZE_89: usize = 2; const IN_89: usize = 2; const OUT_89: usize = 2; fn aiur_fn_89( - inp: [G; IN_89], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(89); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_89] = [__v_4, __v_0]; - record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[89].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_89] = [__v_13, __v_11]; - record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[89].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8633,20 +8724,21 @@ const INPUT_SIZE_90: usize = 3; const IN_90: usize = 3; const OUT_90: usize = 1; fn aiur_fn_90( - inp: [G; IN_90], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(90); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_90] = [__v_3]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8657,11 +8749,11 @@ fn aiur_fn_90( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5, __v_7, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_3 + __v_8); let __ret: [G; OUT_90] = [__v_9]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8669,10 +8761,10 @@ fn aiur_fn_90( let __v_4: G = (__v_0 - __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4, __v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_90] = [__v_7]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8685,14 +8777,15 @@ const INPUT_SIZE_91: usize = 1; const IN_91: usize = 1; const OUT_91: usize = 63; fn aiur_fn_91( - inp: [G; IN_91], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + record.checkpoint(91); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -8703,7 +8796,7 @@ fn aiur_fn_91( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -8714,7 +8807,7 @@ fn aiur_fn_91( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[81].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i)?; } record.function_queries[81].output_at(__i).to_array::() }, _ => aiur_fn_81(__key, 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]; @@ -8725,7 +8818,7 @@ fn aiur_fn_91( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -8736,29 +8829,29 @@ fn aiur_fn_91( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_42]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_44, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_44, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_48, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_48, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_51, __v_55, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, 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); @@ -8773,10 +8866,10 @@ fn aiur_fn_91( let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_61; let __vj = __v_62; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_63; let __vj = __v_64; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_65; let __vj = __v_66; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_67; let __vj = __v_68; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_69: G = G::from_u64(1020); let __v_70: G = (__v_68 - __v_69); let __v_71: G = (__v_67 + __v_70); @@ -8830,10 +8923,10 @@ fn aiur_fn_91( 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); }; + if !unconstrained { let __vi = __v_107; let __vj = __v_108; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_109; let __vj = __v_110; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_111; let __vj = __v_112; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_113; let __vj = __v_114; 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); @@ -8886,10 +8979,10 @@ fn aiur_fn_91( let __v_157: G = G::from_u8(__gb[5]); let __v_158: G = G::from_u8(__gb[6]); let __v_159: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_152; let __vj = __v_153; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_154; let __vj = __v_155; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_156; let __vj = __v_157; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_158; let __vj = __v_159; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_152; let __vj = __v_153; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_154; let __vj = __v_155; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_156; let __vj = __v_157; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_158; let __vj = __v_159; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_160: G = G::from_u64(1020); let __v_161: G = (__v_159 - __v_160); let __v_162: G = (__v_158 + __v_161); @@ -8934,7 +9027,7 @@ fn aiur_fn_91( return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_91] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54]; - record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[91].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8943,69 +9036,70 @@ const INPUT_SIZE_92: usize = 57; const IN_92: usize = 57; const OUT_92: usize = 1; fn aiur_fn_92( - inp: [G; IN_92], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; + record.checkpoint(92); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; let __v_57: G = G::from_u64(0); let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); @@ -9013,15 +9107,15 @@ fn aiur_fn_92( let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(0); let __v_63: G = G::from_u64(0); - let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_92] = [__v_70]; - record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[92].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9030,28 +9124,29 @@ const INPUT_SIZE_93: usize = 2; const IN_93: usize = 2; const OUT_93: usize = 3; fn aiur_fn_93( - inp: [G; IN_93], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(93); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_93] = [__v_4, __v_7, __v_0]; - record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[93].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9062,7 +9157,7 @@ fn aiur_fn_93( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9073,7 +9168,7 @@ fn aiur_fn_93( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[81].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i)?; } record.function_queries[81].output_at(__i).to_array::() }, _ => aiur_fn_81(__key, 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]; @@ -9084,7 +9179,7 @@ fn aiur_fn_93( let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9095,29 +9190,29 @@ fn aiur_fn_93( let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_45, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_45, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_53, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_53, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(0); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_52, __v_56, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_52, __v_56, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, 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); @@ -9132,10 +9227,10 @@ fn aiur_fn_93( let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_66; let __vj = __v_67; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_68; let __vj = __v_69; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_70: G = G::from_u64(1020); let __v_71: G = (__v_69 - __v_70); let __v_72: G = (__v_68 + __v_71); @@ -9189,10 +9284,10 @@ fn aiur_fn_93( let __v_113: G = G::from_u8(__gb[5]); let __v_114: G = G::from_u8(__gb[6]); let __v_115: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_112; let __vj = __v_113; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_114; let __vj = __v_115; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_108; let __vj = __v_109; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_110; let __vj = __v_111; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_112; let __vj = __v_113; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_114; let __vj = __v_115; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_116: G = G::from_u64(1020); let __v_117: G = (__v_115 - __v_116); let __v_118: G = (__v_114 + __v_117); @@ -9245,10 +9340,10 @@ fn aiur_fn_93( let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_153; let __vj = __v_154; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_155; let __vj = __v_156; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_157; let __vj = __v_158; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_159; let __vj = __v_160; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_161: G = G::from_u64(1020); let __v_162: G = (__v_160 - __v_161); let __v_163: G = (__v_159 + __v_162); @@ -9294,12 +9389,12 @@ fn aiur_fn_93( } let __v_198: G = G::from_u64(1); let __v_199: G = (__v_1 - __v_198); - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_55, __v_199]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_55, __v_199]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_200: G = __r_arr[0]; let __v_201: G = __r_arr[1]; let __v_202: G = __r_arr[2]; let __v_203: G = G::from_u64(0); - let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_205: G = G::from_u64(0); let __v_206: G = G::from_u64(0); let __v_207: G = G::from_u64(0); @@ -9307,15 +9402,15 @@ fn aiur_fn_93( let __v_209: G = G::from_u64(0); let __v_210: G = G::from_u64(0); let __v_211: G = G::from_u64(0); - let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_93] = [__v_204, __v_218, __v_202]; - record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[93].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9326,14 +9421,15 @@ const INPUT_SIZE_94: usize = 1; const IN_94: usize = 1; const OUT_94: usize = 3; fn aiur_fn_94( - inp: [G; IN_94], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(94); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -9341,19 +9437,19 @@ fn aiur_fn_94( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); let __ret: [G; OUT_94] = [__v_3, __v_4, __v_2]; - record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[94].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_94] = [__v_7, __v_5, __v_6]; - record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[94].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9364,30 +9460,31 @@ const INPUT_SIZE_95: usize = 2; const IN_95: usize = 2; const OUT_95: usize = 2; fn aiur_fn_95( - inp: [G; IN_95], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(95); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_95] = [__v_4, __v_0]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -9395,17 +9492,17 @@ fn aiur_fn_95( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_95] = [__v_11, __v_7]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_95] = [__v_10, __v_7]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9418,14 +9515,15 @@ const INPUT_SIZE_96: usize = 1; const IN_96: usize = 1; const OUT_96: usize = 9; fn aiur_fn_96( - inp: [G; IN_96], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + record.checkpoint(96); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9436,7 +9534,7 @@ fn aiur_fn_96( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9447,7 +9545,7 @@ fn aiur_fn_96( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9458,7 +9556,7 @@ fn aiur_fn_96( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9469,7 +9567,7 @@ fn aiur_fn_96( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9480,7 +9578,7 @@ fn aiur_fn_96( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9491,7 +9589,7 @@ fn aiur_fn_96( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9511,16 +9609,16 @@ fn aiur_fn_96( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_96] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9529,14 +9627,15 @@ const INPUT_SIZE_97: usize = 1; const IN_97: usize = 1; const OUT_97: usize = 13; fn aiur_fn_97( - inp: [G; IN_97], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + record.checkpoint(97); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9547,7 +9646,7 @@ fn aiur_fn_97( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9558,7 +9657,7 @@ fn aiur_fn_97( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9569,7 +9668,7 @@ fn aiur_fn_97( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9580,7 +9679,7 @@ fn aiur_fn_97( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9591,7 +9690,7 @@ fn aiur_fn_97( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9602,7 +9701,7 @@ fn aiur_fn_97( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9622,15 +9721,15 @@ fn aiur_fn_97( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9641,23 +9740,23 @@ fn aiur_fn_97( let __v_95: G = __r_arr[7]; let __v_96: G = __r_arr[8]; let __v_97: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97, __v_88]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_100]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_100]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[94].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i)?; } record.function_queries[94].output_at(__i).to_array::() }, _ => aiur_fn_94(__key, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_87, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_87, __v_107]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, 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]; - record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[97].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9666,27 +9765,28 @@ const INPUT_SIZE_98: usize = 5; const IN_98: usize = 5; const OUT_98: usize = 1; fn aiur_fn_98( - inp: [G; IN_98], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(98); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_98] = [__v_12]; - record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[98].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9695,63 +9795,64 @@ const INPUT_SIZE_99: usize = 33; const IN_99: usize = 33; const OUT_99: usize = 1; fn aiur_fn_99( - inp: [G; IN_99], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + record.checkpoint(99); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_99] = [__v_40]; - record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[99].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9760,46 +9861,47 @@ const INPUT_SIZE_100: usize = 32; const IN_100: usize = 32; const OUT_100: usize = 32; fn aiur_fn_100( - inp: [G; IN_100], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(100); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; let __ret: [G; OUT_100] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; - record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[100].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9808,14 +9910,15 @@ const INPUT_SIZE_101: usize = 2; const IN_101: usize = 2; const OUT_101: usize = 1; fn aiur_fn_101( - inp: [G; IN_101], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(101); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); @@ -9848,7 +9951,7 @@ fn aiur_fn_101( let __v_31: G = G::from_u64(205); let __v_32: G = G::from_u64(224); let __v_33: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -9881,7 +9984,7 @@ fn aiur_fn_101( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_66: G = __loaded[0]; let __v_67: G = __loaded[1]; let __v_68: G = __loaded[2]; @@ -9947,7 +10050,7 @@ fn aiur_fn_101( let __v_128: G = G::from_u64(0); let __v_129: G = G::from_u64(0); let __v_130: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -9980,9 +10083,9 @@ fn aiur_fn_101( let __v_160: G = __r_arr[29]; let __v_161: G = __r_arr[30]; let __v_162: G = __r_arr[31]; - let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_101] = [__v_163]; - record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[101].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9991,28 +10094,29 @@ const INPUT_SIZE_102: usize = 3; const IN_102: usize = 3; const OUT_102: usize = 1; fn aiur_fn_102( - inp: [G; IN_102], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(102); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_102] = [__v_3]; - record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[102].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_102] = [__v_3]; - record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[102].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10023,15 +10127,16 @@ const INPUT_SIZE_103: usize = 2; const IN_103: usize = 2; const OUT_103: usize = 1; fn aiur_fn_103( - inp: [G; IN_103], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(103); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10039,7 +10144,7 @@ fn aiur_fn_103( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_103] = [__v_5]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -10049,14 +10154,14 @@ fn aiur_fn_103( 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_103] = [__v_7]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_7]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10072,16 +10177,17 @@ const INPUT_SIZE_104: usize = 3; const IN_104: usize = 3; const OUT_104: usize = 1; fn aiur_fn_104( - inp: [G; IN_104], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(104); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -10089,13 +10195,13 @@ fn aiur_fn_104( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_104] = [__v_8]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -10105,14 +10211,14 @@ fn aiur_fn_104( let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_11]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -10125,19 +10231,19 @@ fn aiur_fn_104( let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_21]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_104] = [__v_23]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10160,16 +10266,17 @@ const INPUT_SIZE_105: usize = 3; const IN_105: usize = 3; const OUT_105: usize = 1; fn aiur_fn_105( - inp: [G; IN_105], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(105); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -10177,29 +10284,29 @@ fn aiur_fn_105( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_105] = [__v_8]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_10]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -10212,19 +10319,19 @@ fn aiur_fn_105( let __v_19: G = __loaded[9]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_20]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_105] = [__v_22]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10247,15 +10354,16 @@ const INPUT_SIZE_106: usize = 2; const IN_106: usize = 2; const OUT_106: usize = 11; fn aiur_fn_106( - inp: [G; IN_106], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(106); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10298,10 +10406,10 @@ fn aiur_fn_106( let __v_38: G = G::from_u8(__gb[5]); let __v_39: G = G::from_u8(__gb[6]); let __v_40: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_33; let __vj = __v_34; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_35; let __vj = __v_36; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_37; let __vj = __v_38; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_39; let __vj = __v_40; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_41: G = G::from_u64(1020); let __v_42: G = (__v_40 - __v_41); let __v_43: G = (__v_39 + __v_42); @@ -10347,11 +10455,11 @@ fn aiur_fn_106( } let __v_78: G = G::from_u64(1); let __ret: [G; OUT_106] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -10367,11 +10475,11 @@ fn aiur_fn_106( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __ret: [G; OUT_106] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10384,7 +10492,7 @@ fn aiur_fn_106( let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; let __ret: [G; OUT_106] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10403,19 +10511,20 @@ const INPUT_SIZE_107: usize = 6; const IN_107: usize = 6; const OUT_107: usize = 1; fn aiur_fn_107( - inp: [G; IN_107], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + record.checkpoint(107); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10429,7 +10538,7 @@ fn aiur_fn_107( let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -10454,7 +10563,7 @@ fn aiur_fn_107( 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -10551,7 +10660,7 @@ fn aiur_fn_107( let __v_118: G = G::from_u64(0); let __v_119: G = G::from_u64(0); let __v_120: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; @@ -10586,7 +10695,7 @@ fn aiur_fn_107( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -10619,69 +10728,69 @@ fn aiur_fn_107( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_107] = [__v_187]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10693,7 +10802,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10705,7 +10814,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_36, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10717,7 +10826,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10729,7 +10838,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_58, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_58, __v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10741,7 +10850,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_69, __v_70]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_69, __v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10753,7 +10862,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_80, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10774,7 +10883,7 @@ fn aiur_fn_107( let __v_100: G = (__v_27 + __v_99); let __v_101: G = (__v_16 + __v_100); let __v_102: G = (__v_94 * __v_101); - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; @@ -10787,7 +10896,7 @@ fn aiur_fn_107( let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; @@ -10816,7 +10925,7 @@ fn aiur_fn_107( let __v_118: G = (__v_113 * __v_116); let __v_119: G = (__v_116 - __v_118); let __v_120: G = (__v_113 + __v_119); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; @@ -10825,7 +10934,7 @@ fn aiur_fn_107( let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -10834,7 +10943,7 @@ fn aiur_fn_107( let __v_134: G = (__v_133 * __v_130); let __v_135: G = (__v_132 + __v_134); let __v_136: G = (__v_117 + __v_135); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -10867,7 +10976,7 @@ fn aiur_fn_107( let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; @@ -10899,7 +11008,7 @@ fn aiur_fn_107( let __v_197: G = G::from_u64(0); let __v_198: G = G::from_u64(0); let __v_199: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -10935,9 +11044,9 @@ fn aiur_fn_107( match __v_113.as_canonical_u64() { 1u64 => { let __v_232: G = G::from_u64(0); - let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_107] = [__v_233]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10976,7 +11085,7 @@ fn aiur_fn_107( let __v_262: G = G::from_u64(224); let __v_263: G = G::from_u64(91); let __v_264: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_265: G = __loaded[0]; let __v_266: G = __loaded[1]; let __v_267: G = __loaded[2]; @@ -10985,7 +11094,7 @@ fn aiur_fn_107( let __v_270: G = __loaded[5]; let __v_271: G = __loaded[6]; let __v_272: G = __loaded[7]; - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[12].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i)?; } record.function_queries[12].output_at(__i).to_array::() }, _ => aiur_fn_12(__key, 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]; @@ -10994,24 +11103,24 @@ fn aiur_fn_107( let __v_278: G = __r_arr[5]; let __v_279: G = __r_arr[6]; let __v_280: G = __r_arr[7]; - let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_285: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_285]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_235]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11026,13 +11135,14 @@ const INPUT_SIZE_108: usize = 1; const IN_108: usize = 1; const OUT_108: usize = 32; fn aiur_fn_108( - inp: [G; IN_108], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(108); + let __v_0: G = inp.values()[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); @@ -11067,7 +11177,7 @@ fn aiur_fn_108( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -11077,14 +11187,14 @@ fn aiur_fn_108( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -11118,7 +11228,7 @@ fn aiur_fn_108( let __v_81: G = __r_arr[30]; let __v_82: G = __r_arr[31]; let __ret: [G; OUT_108] = [__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]; - record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[108].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -11127,16 +11237,17 @@ const INPUT_SIZE_109: usize = 3; const IN_109: usize = 3; const OUT_109: usize = 1; fn aiur_fn_109( - inp: [G; IN_109], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + record.checkpoint(109); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, 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); @@ -11172,7 +11283,7 @@ fn aiur_fn_109( let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); @@ -11182,14 +11293,14 @@ fn aiur_fn_109( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -11222,9 +11333,9 @@ fn aiur_fn_109( let __v_83: G = __r_arr[29]; let __v_84: G = __r_arr[30]; let __v_85: G = __r_arr[31]; - let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_109] = [__v_86]; - record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[109].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -11233,31 +11344,32 @@ const INPUT_SIZE_110: usize = 4; const IN_110: usize = 4; const OUT_110: usize = 1; fn aiur_fn_110( - inp: [G; IN_110], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + record.checkpoint(110); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_110] = [__v_3]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[109].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i)?; } record.function_queries[109].output_at(__i).to_array::() }, _ => aiur_fn_109(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_6]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11268,14 +11380,15 @@ const INPUT_SIZE_111: usize = 1; const IN_111: usize = 1; const OUT_111: usize = 1; fn aiur_fn_111( - inp: [G; IN_111], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(111); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11283,17 +11396,17 @@ fn aiur_fn_111( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_111] = [__v_4]; - record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[111].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, 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_111] = [__v_7]; - record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[111].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11307,15 +11420,16 @@ const INPUT_SIZE_112: usize = 2; const IN_112: usize = 2; const OUT_112: usize = 1; fn aiur_fn_112( - inp: [G; IN_112], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(112); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11325,11 +11439,11 @@ fn aiur_fn_112( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_112] = [__v_1]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -11339,7 +11453,7 @@ fn aiur_fn_112( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_112] = [__v_0]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -11347,16 +11461,16 @@ fn aiur_fn_112( _ => { match __v_9.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_112] = [__v_17]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11371,20 +11485,20 @@ fn aiur_fn_112( return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_112] = [__v_19]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_112] = [__v_19]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11411,14 +11525,15 @@ const INPUT_SIZE_113: usize = 1; const IN_113: usize = 1; const OUT_113: usize = 2; fn aiur_fn_113( - inp: [G; IN_113], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(113); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11429,16 +11544,16 @@ fn aiur_fn_113( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_113] = [__v_9, __v_12]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -11450,25 +11565,25 @@ fn aiur_fn_113( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_113] = [__v_17, __v_20]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[113].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i)?; } record.function_queries[113].output_at(__i).to_array::() }, _ => aiur_fn_113(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_113] = [__v_16, __v_18]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11487,14 +11602,15 @@ const INPUT_SIZE_114: usize = 1; const IN_114: usize = 1; const OUT_114: usize = 1; fn aiur_fn_114( - inp: [G; IN_114], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(114); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11504,11 +11620,11 @@ fn aiur_fn_114( match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_114] = [__v_0]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -11518,21 +11634,21 @@ fn aiur_fn_114( match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_114] = [__v_0]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[113].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i)?; } record.function_queries[113].output_at(__i).to_array::() }, _ => aiur_fn_113(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_17]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11551,23 +11667,24 @@ const INPUT_SIZE_115: usize = 4; const IN_115: usize = 4; const OUT_115: usize = 1; fn aiur_fn_115( - inp: [G; IN_115], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(115); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { @@ -11575,28 +11692,28 @@ fn aiur_fn_115( } let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_115] = [__v_11]; - record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[115].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[109].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i)?; } record.function_queries[109].output_at(__i).to_array::() }, _ => aiur_fn_109(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6, __v_9, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_115] = [__v_14]; - record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[115].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11615,17 +11732,18 @@ const INPUT_SIZE_116: usize = 4; const IN_116: usize = 4; const OUT_116: usize = 2; fn aiur_fn_116( - inp: [G; IN_116], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(116); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -11636,23 +11754,23 @@ fn aiur_fn_116( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_12, __v_1]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_111] = { let __args: [G; IN_111] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -11663,56 +11781,56 @@ fn aiur_fn_116( 0u64 => { match __v_15.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_13 - __v_23); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_19, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_7, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_17, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_27, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_33, __v_29]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[102].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i)?; } record.function_queries[102].output_at(__i).to_array::() }, _ => aiur_fn_102(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_28, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_34, __v_32]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11730,23 +11848,23 @@ fn aiur_fn_116( } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[102].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i)?; } record.function_queries[102].output_at(__i).to_array::() }, _ => aiur_fn_102(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_29, __v_22]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11777,35 +11895,36 @@ const INPUT_SIZE_117: usize = 4; const IN_117: usize = 4; const OUT_117: usize = 2; fn aiur_fn_117( - inp: [G; IN_117], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(117); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_117] = [__v_0, __v_1]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[117].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_3 - __v_4); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 - __v_8); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_6, __v_7, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_6, __v_7, __v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_117] = [__v_10, __v_11]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[117].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11816,26 +11935,27 @@ const INPUT_SIZE_118: usize = 6; const IN_118: usize = 6; const OUT_118: usize = 1; fn aiur_fn_118( - inp: [G; IN_118], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(118); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_4, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_4, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -11846,9 +11966,9 @@ fn aiur_fn_118( 0u64 => { match __v_11.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_bool((__v_18 == G::ZERO)); @@ -11856,24 +11976,24 @@ fn aiur_fn_118( if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_14); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __ret: [G; OUT_118] = [__v_27]; - record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[118].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11889,31 +12009,32 @@ const INPUT_SIZE_119: usize = 2; const IN_119: usize = 2; const OUT_119: usize = 1; fn aiur_fn_119( - inp: [G; IN_119], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(119); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_1]; - record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_119] = [__v_7]; - record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11927,15 +12048,16 @@ const INPUT_SIZE_120: usize = 2; const IN_120: usize = 2; const OUT_120: usize = 1; fn aiur_fn_120( - inp: [G; IN_120], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(120); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11943,23 +12065,23 @@ fn aiur_fn_120( 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_120] = [__v_5]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_120] = [__v_6]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); let __ret: [G; OUT_120] = [__v_7]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11975,30 +12097,31 @@ const INPUT_SIZE_121: usize = 8; const IN_121: usize = 8; const OUT_121: usize = 2; fn aiur_fn_121( - inp: [G; IN_121], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(121); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, 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); @@ -12081,7 +12204,7 @@ fn aiur_fn_121( let __v_82: G = (__v_42 + __v_78); let __v_83: G = (__v_45 + __v_81); let __ret: [G; OUT_121] = [__v_82, __v_83]; - record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[121].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -12090,27 +12213,28 @@ const INPUT_SIZE_122: usize = 2; const IN_122: usize = 2; const OUT_122: usize = 1; fn aiur_fn_122( - inp: [G; IN_122], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(122); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(7); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_2 * __v_8); let __ret: [G; OUT_122] = [__v_9]; - record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -12119,21 +12243,22 @@ const INPUT_SIZE_123: usize = 8; const IN_123: usize = 8; const OUT_123: usize = 4; fn aiur_fn_123( - inp: [G; IN_123], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(123); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -12147,11 +12272,11 @@ fn aiur_fn_123( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_123] = [__v_4, __v_5, __v_6, __v_7]; - record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[123].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -12200,13 +12325,13 @@ fn aiur_fn_123( 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_123] = { let __args: [G; IN_123] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, 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_123] = [__v_64, __v_65, __v_66, __v_67]; - record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[123].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12225,15 +12350,16 @@ const INPUT_SIZE_124: usize = 2; const IN_124: usize = 2; const OUT_124: usize = 1; fn aiur_fn_124( - inp: [G; IN_124], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(124); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -12241,7 +12367,7 @@ fn aiur_fn_124( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_124] = [__v_1]; - record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12254,10 +12380,10 @@ fn aiur_fn_124( let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_6; let __vj = __v_7; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_12; let __vj = __v_13; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_14: G = G::from_u64(1020); let __v_15: G = (__v_13 - __v_14); let __v_16: G = (__v_12 + __v_15); @@ -12277,10 +12403,10 @@ fn aiur_fn_124( let __v_29: G = G::from_u8(__gb[5]); let __v_30: G = G::from_u8(__gb[6]); let __v_31: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_28; let __vj = __v_29; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_30; let __vj = __v_31; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_32: G = G::from_u64(1020); let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 + __v_33); @@ -12357,14 +12483,14 @@ fn aiur_fn_124( 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_124] = { let __args: [G; IN_124] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_98]; - record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12378,31 +12504,32 @@ const INPUT_SIZE_125: usize = 2; const IN_125: usize = 2; const OUT_125: usize = 1; fn aiur_fn_125( - inp: [G; IN_125], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(125); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_125] = [__v_1]; - record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[125].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_125] = [__v_6]; - record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[125].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12416,31 +12543,32 @@ const INPUT_SIZE_126: usize = 2; const IN_126: usize = 2; const OUT_126: usize = 1; fn aiur_fn_126( - inp: [G; IN_126], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(126); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_126] = [__v_1]; - record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[126].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_6]; - record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[126].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12454,26 +12582,27 @@ const INPUT_SIZE_127: usize = 3; const IN_127: usize = 3; const OUT_127: usize = 1; fn aiur_fn_127( - inp: [G; IN_127], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(127); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_2]; - record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[127].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_3]; - record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[127].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12487,22 +12616,23 @@ const INPUT_SIZE_128: usize = 2; const IN_128: usize = 2; const OUT_128: usize = 1; fn aiur_fn_128( - inp: [G; IN_128], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(128); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_128] = [__v_0]; - record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[128].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12514,12 +12644,12 @@ fn aiur_fn_128( 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_171] = { let __args: [G; IN_171] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_13, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_13, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_128] = [__v_14]; - record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[128].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12533,49 +12663,50 @@ const INPUT_SIZE_129: usize = 10; const IN_129: usize = 10; const OUT_129: usize = 2; fn aiur_fn_129( - inp: [G; IN_129], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(129); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_129] = [__v_0, __v_12]; - record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[129].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_10, __v_13, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, 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_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, 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_129] = [__v_15, __v_16]; - record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[129].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12586,17 +12717,18 @@ const INPUT_SIZE_130: usize = 4; const IN_130: usize = 4; const OUT_130: usize = 2; fn aiur_fn_130( - inp: [G; IN_130], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(130); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -12604,13 +12736,13 @@ fn aiur_fn_130( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_130] = [__v_9, __v_0]; - record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[130].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -12623,12 +12755,12 @@ fn aiur_fn_130( let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -12647,7 +12779,7 @@ fn aiur_fn_130( 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_130] = { let __args: [G; IN_130] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_36, __v_6, __v_16, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, 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); @@ -12693,9 +12825,9 @@ fn aiur_fn_130( let __v_80: G = (__v_65 + __v_79); let __v_81: G = (__v_63 + __v_80); let __v_82: G = (__v_28 + __v_81); - let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_130] = [__v_83, __v_39]; - record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[130].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12714,26 +12846,27 @@ const INPUT_SIZE_131: usize = 5; const IN_131: usize = 5; const OUT_131: usize = 1; fn aiur_fn_131( - inp: [G; IN_131], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(131); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_131] = [__v_5]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, 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); @@ -12742,7 +12875,7 @@ fn aiur_fn_131( 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_131] = [__v_9]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12750,10 +12883,10 @@ fn aiur_fn_131( 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_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[131].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i)?; } record.function_queries[131].output_at(__i).to_array::() }, _ => aiur_fn_131(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_13]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12766,37 +12899,38 @@ const INPUT_SIZE_132: usize = 4; const IN_132: usize = 4; const OUT_132: usize = 1; fn aiur_fn_132( - inp: [G; IN_132], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(132); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_132] = [__v_6]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[131].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i)?; } record.function_queries[131].output_at(__i).to_array::() }, _ => aiur_fn_131(__key, 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_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_8]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12807,11 +12941,11 @@ fn aiur_fn_132( 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_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_132] = [__v_14]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12824,21 +12958,22 @@ const INPUT_SIZE_133: usize = 8; const IN_133: usize = 8; const OUT_133: usize = 1; fn aiur_fn_133( - inp: [G; IN_133], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(133); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -12850,9 +12985,9 @@ fn aiur_fn_133( 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_133] = [__v_17]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12864,7 +12999,7 @@ fn aiur_fn_133( 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, 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]; @@ -12880,18 +13015,18 @@ fn aiur_fn_133( let __v_31: G = (__v_12 + __v_27); let __v_32: G = (__v_13 + __v_30); let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_133] = [__v_34]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_133] = [__v_19]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12909,15 +13044,16 @@ const INPUT_SIZE_134: usize = 2; const IN_134: usize = 2; const OUT_134: usize = 1; fn aiur_fn_134( - inp: [G; IN_134], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(134); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -12929,7 +13065,7 @@ fn aiur_fn_134( 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_134] = [__v_9]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12952,14 +13088,14 @@ fn aiur_fn_134( } let __v_19: G = G::from_u64(1); let __ret: [G; OUT_134] = [__v_19]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_11]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12977,25 +13113,26 @@ const INPUT_SIZE_135: usize = 2; const IN_135: usize = 2; const OUT_135: usize = 1; fn aiur_fn_135( - inp: [G; IN_135], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(135); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_135] = [__v_2]; - record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[135].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_135] = [__v_2]; - record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[135].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13009,34 +13146,35 @@ const INPUT_SIZE_136: usize = 10; const IN_136: usize = 10; const OUT_136: usize = 1; fn aiur_fn_136( - inp: [G; IN_136], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; + record.checkpoint(136); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; let __v_10: G = (__v_3 - __v_1); - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_11, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_11, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, 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); @@ -13065,9 +13203,9 @@ fn aiur_fn_136( 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_250] = { let __args: [G; IN_250] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, 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)); @@ -13075,10 +13213,10 @@ fn aiur_fn_136( 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_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_45]; - record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[136].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13087,30 +13225,31 @@ const INPUT_SIZE_137: usize = 11; const IN_137: usize = 11; const OUT_137: usize = 1; fn aiur_fn_137( - inp: [G; IN_137], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - 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]; + record.checkpoint(137); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -13121,12 +13260,12 @@ fn aiur_fn_137( 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_136] = { let __args: [G; IN_136] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_26]; - record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[137].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13135,49 +13274,50 @@ const INPUT_SIZE_138: usize = 13; const IN_138: usize = 13; const OUT_138: usize = 1; fn aiur_fn_138( - inp: [G; IN_138], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(138); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_138] = [__v_0]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[138].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, 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_138] = { let __args: [G; IN_138] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_22]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[138].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13188,52 +13328,53 @@ const INPUT_SIZE_139: usize = 13; const IN_139: usize = 13; const OUT_139: usize = 1; fn aiur_fn_139( - inp: [G; IN_139], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - 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]; + record.checkpoint(139); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_139] = [__v_0]; - record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[139].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_10, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, 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_139] = { let __args: [G; IN_139] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[139].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i)?; } record.function_queries[139].output_at(__i).to_array::() }, _ => aiur_fn_139(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_24]; - record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[139].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13244,35 +13385,36 @@ const INPUT_SIZE_140: usize = 15; const IN_140: usize = 15; const OUT_140: usize = 1; fn aiur_fn_140( - inp: [G; IN_140], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - 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]; + record.checkpoint(140); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_140] = [__v_0]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -13281,21 +13423,21 @@ fn aiur_fn_140( 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_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_21]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_11, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, 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); @@ -13303,10 +13445,10 @@ fn aiur_fn_140( 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_140] = { let __args: [G; IN_140] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_28]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13322,47 +13464,48 @@ const INPUT_SIZE_141: usize = 15; const IN_141: usize = 15; const OUT_141: usize = 1; fn aiur_fn_141( - inp: [G; IN_141], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __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]; + record.checkpoint(141); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_141] = [__v_0]; - record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[141].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_20 - __v_21); let __v_23: G = G::from_bool((__v_22 == G::ZERO)); @@ -13372,10 +13515,10 @@ fn aiur_fn_141( } let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_27]; - record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[141].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13391,39 +13534,40 @@ const INPUT_SIZE_142: usize = 4; const IN_142: usize = 4; const OUT_142: usize = 1; fn aiur_fn_142( - inp: [G; IN_142], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(142); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_142] = [__v_6]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[142].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, 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_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_142] = [__v_12]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[142].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13434,14 +13578,15 @@ const INPUT_SIZE_143: usize = 1; const IN_143: usize = 1; const OUT_143: usize = 1; fn aiur_fn_143( - inp: [G; IN_143], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(143); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -13449,22 +13594,22 @@ fn aiur_fn_143( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_143] = [__v_4]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, 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 }; + 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_143] = [__v_4]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_143] = [__v_2]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13480,28 +13625,29 @@ const INPUT_SIZE_144: usize = 5; const IN_144: usize = 5; const OUT_144: usize = 1; fn aiur_fn_144( - inp: [G; IN_144], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(144); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_144] = [__v_7]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -13510,26 +13656,26 @@ fn aiur_fn_144( 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_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_11]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, 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_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_144] = [__v_15]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13545,26 +13691,27 @@ const INPUT_SIZE_145: usize = 5; const IN_145: usize = 5; const OUT_145: usize = 4; fn aiur_fn_145( - inp: [G; IN_145], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(145); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_145] = [__v_1, __v_2, __v_3, __v_4]; - record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_145] = [__v_3, __v_4, __v_1, __v_2]; - record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13575,16 +13722,17 @@ const INPUT_SIZE_146: usize = 4; const IN_146: usize = 4; const OUT_146: usize = 1; fn aiur_fn_146( - inp: [G; IN_146], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(146); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); @@ -13594,10 +13742,10 @@ fn aiur_fn_146( let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_4; let __vj = __v_5; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_6; let __vj = __v_7; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_12: G = G::from_u64(1020); let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_10 + __v_13); @@ -13617,10 +13765,10 @@ fn aiur_fn_146( let __v_27: G = G::from_u8(__gb[5]); let __v_28: G = G::from_u8(__gb[6]); let __v_29: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_22; let __vj = __v_23; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_22; let __vj = __v_23; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_28; let __vj = __v_29; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_30: G = G::from_u64(1020); let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 + __v_31); @@ -13640,10 +13788,10 @@ fn aiur_fn_146( let __v_45: G = G::from_u8(__gb[5]); let __v_46: G = G::from_u8(__gb[6]); let __v_47: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_44; let __vj = __v_45; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_46; let __vj = __v_47; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_48: G = G::from_u64(1020); let __v_49: G = (__v_47 - __v_48); let __v_50: G = (__v_46 + __v_49); @@ -13663,10 +13811,10 @@ fn aiur_fn_146( let __v_63: G = G::from_u8(__gb[5]); let __v_64: G = G::from_u8(__gb[6]); let __v_65: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_66: G = G::from_u64(1020); let __v_67: G = (__v_65 - __v_66); let __v_68: G = (__v_64 + __v_67); @@ -13815,13 +13963,13 @@ fn aiur_fn_146( } let __v_188: G = G::from_u64(1); let __v_189: G = G::from_u64(1); - let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_146] = [__v_194]; - record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[146].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13830,19 +13978,20 @@ const INPUT_SIZE_147: usize = 6; const IN_147: usize = 6; const OUT_147: usize = 3; fn aiur_fn_147( - inp: [G; IN_147], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(147); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -13853,7 +14002,7 @@ fn aiur_fn_147( match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_147] = [__v_0, __v_1, __v_5]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -13864,7 +14013,7 @@ fn aiur_fn_147( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_3, __v_4, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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); @@ -13878,12 +14027,12 @@ fn aiur_fn_147( let __v_26: G = (__v_0 + __v_22); let __v_27: G = (__v_1 + __v_25); let __ret: [G; OUT_147] = [__v_26, __v_27, __v_12]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_147] = [__v_0, __v_1, __v_5]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13901,22 +14050,23 @@ const INPUT_SIZE_148: usize = 9; const IN_148: usize = 9; const OUT_148: usize = 3; fn aiur_fn_148( - inp: [G; IN_148], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(148); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -13929,7 +14079,7 @@ fn aiur_fn_148( if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { @@ -13937,20 +14087,20 @@ fn aiur_fn_148( } let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_148] = [__v_0, __v_1, __v_20]; - record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[148].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -13958,7 +14108,7 @@ fn aiur_fn_148( 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -13967,7 +14117,7 @@ fn aiur_fn_148( let __v_23: G = G::from_u64(1); let __v_24: G = (__v_6 - __v_23); let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_11, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_11, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() { @@ -13983,14 +14133,14 @@ fn aiur_fn_148( let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = __mc_out___mc_0[2]; let __v_31: G = __mc_out___mc_0[3]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[121].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i)?; } record.function_queries[121].output_at(__i).to_array::() }, _ => aiur_fn_121(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[147].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i)?; } record.function_queries[147].output_at(__i).to_array::() }, _ => aiur_fn_147(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[148].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i)?; } record.function_queries[148].output_at(__i).to_array::() }, _ => aiur_fn_148(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -14003,10 +14153,10 @@ fn aiur_fn_148( let __v_45: G = G::from_u8(__gb[5]); let __v_46: G = G::from_u8(__gb[6]); let __v_47: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_44; let __vj = __v_45; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_46; let __vj = __v_47; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_48: G = G::from_u64(1020); let __v_49: G = (__v_47 - __v_48); let __v_50: G = (__v_46 + __v_49); @@ -14026,10 +14176,10 @@ fn aiur_fn_148( let __v_63: G = G::from_u8(__gb[5]); let __v_64: G = G::from_u8(__gb[6]); let __v_65: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_66: G = G::from_u64(1020); let __v_67: G = (__v_65 - __v_66); let __v_68: G = (__v_64 + __v_67); @@ -14049,10 +14199,10 @@ fn aiur_fn_148( let __v_81: G = G::from_u8(__gb[5]); let __v_82: G = G::from_u8(__gb[6]); let __v_83: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_82; let __vj = __v_83; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_76; let __vj = __v_77; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_78; let __vj = __v_79; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_80; let __vj = __v_81; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_82; let __vj = __v_83; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_84: G = G::from_u64(1020); let __v_85: G = (__v_83 - __v_84); let __v_86: G = (__v_82 + __v_85); @@ -14072,10 +14222,10 @@ fn aiur_fn_148( let __v_99: G = G::from_u8(__gb[5]); let __v_100: G = G::from_u8(__gb[6]); let __v_101: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_94; let __vj = __v_95; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_96; let __vj = __v_97; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_98; let __vj = __v_99; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_100; let __vj = __v_101; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_94; let __vj = __v_95; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_96; let __vj = __v_97; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_98; let __vj = __v_99; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_100; let __vj = __v_101; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_102: G = G::from_u64(1020); let __v_103: G = (__v_101 - __v_102); let __v_104: G = (__v_100 + __v_103); @@ -14086,7 +14236,7 @@ fn aiur_fn_148( let __v_109: G = (__v_95 + __v_108); let __v_110: G = (__v_94 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = G::from_u64(1); if (__v_112 != __v_113) { @@ -14231,14 +14381,14 @@ fn aiur_fn_148( } let __v_227: G = G::from_u64(1); let __v_228: G = G::from_u64(1); - let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_148] = [__v_37, __v_38, __v_234]; - record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[148].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14269,73 +14419,74 @@ const INPUT_SIZE_149: usize = 25; const IN_149: usize = 25; const OUT_149: usize = 1; fn aiur_fn_149( - inp: [G; IN_149], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; + record.checkpoint(149); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_19, __v_18, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_33.as_canonical_u64() { _ => { let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; match __v_37.as_canonical_u64() { _ => { let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[139].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i)?; } record.function_queries[139].output_at(__i).to_array::() }, _ => aiur_fn_139(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[141].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i)?; } record.function_queries[141].output_at(__i).to_array::() }, _ => aiur_fn_141(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_40, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_40, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_42: G = __loaded[0]; let __v_43: G = __loaded[1]; let __v_44: G = __loaded[2]; @@ -14347,15 +14498,15 @@ fn aiur_fn_149( 0u64 => { match __v_43.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[148].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i)?; } record.function_queries[148].output_at(__i).to_array::() }, _ => aiur_fn_148(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_23, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_23, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = (__v_55 - __v_24); let __v_57: G = G::from_bool((__v_56 == G::ZERO)); @@ -14363,10 +14514,10 @@ fn aiur_fn_149( if (__v_57 != __v_58) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 - __v_62); @@ -14375,7 +14526,7 @@ fn aiur_fn_149( if (__v_64 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = (__v_66 - __v_18); let __v_68: G = G::from_bool((__v_67 == G::ZERO)); @@ -14383,7 +14534,7 @@ fn aiur_fn_149( if (__v_68 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = (__v_70 - __v_18); let __v_72: G = G::from_bool((__v_71 == G::ZERO)); @@ -14391,7 +14542,7 @@ fn aiur_fn_149( 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_245] = { let __args: [G; IN_245] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, 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)); @@ -14415,7 +14566,7 @@ fn aiur_fn_149( return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_149] = [__v_51]; - record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[149].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14439,38 +14590,39 @@ const INPUT_SIZE_150: usize = 25; const IN_150: usize = 25; const OUT_150: usize = 1; fn aiur_fn_150( - inp: [G; IN_150], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(150); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -14479,24 +14631,24 @@ fn aiur_fn_150( 1u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_150] = [__v_31]; - record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[150].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, 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_149] = { let __args: [G; IN_149] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[149].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i)?; } record.function_queries[149].output_at(__i).to_array::() }, _ => aiur_fn_149(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_150] = [__v_35]; - record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[150].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14510,38 +14662,39 @@ const INPUT_SIZE_151: usize = 4; const IN_151: usize = 4; const OUT_151: usize = 1; fn aiur_fn_151( - inp: [G; IN_151], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(151); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_151] = [__v_6]; - record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[151].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5, __v_6, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_151] = [__v_11]; - record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[151].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14552,15 +14705,16 @@ const INPUT_SIZE_152: usize = 2; const IN_152: usize = 2; const OUT_152: usize = 1; fn aiur_fn_152( - inp: [G; IN_152], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(152); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14569,22 +14723,22 @@ fn aiur_fn_152( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_152] = [__v_8]; - record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[152].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_152] = [__v_9]; - record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[152].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14600,15 +14754,16 @@ const INPUT_SIZE_153: usize = 2; const IN_153: usize = 2; const OUT_153: usize = 1; fn aiur_fn_153( - inp: [G; IN_153], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(153); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14618,22 +14773,22 @@ fn aiur_fn_153( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_153] = [__v_9]; - record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[153].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_153] = [__v_10]; - record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[153].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14649,40 +14804,41 @@ const INPUT_SIZE_154: usize = 4; const IN_154: usize = 4; const OUT_154: usize = 1; fn aiur_fn_154( - inp: [G; IN_154], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(154); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_154] = [__v_6]; - record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[154].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_154] = [__v_12]; - record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[154].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14693,59 +14849,60 @@ const INPUT_SIZE_155: usize = 13; const IN_155: usize = 13; const OUT_155: usize = 1; fn aiur_fn_155( - inp: [G; IN_155], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(155); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_9, __v_11, __v_10, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { _ => { let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { _ => { let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { @@ -14755,28 +14912,28 @@ fn aiur_fn_155( 0u64 => { let __v_30: G = G::from_u64(1); let __ret: [G; OUT_155] = [__v_30]; - record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[155].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_30: G = G::from_u64(3); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_12 - __v_35); - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_1, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_1, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_155] = [__v_38]; - record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[155].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14798,33 +14955,34 @@ const INPUT_SIZE_156: usize = 2; const IN_156: usize = 2; const OUT_156: usize = 1; fn aiur_fn_156( - inp: [G; IN_156], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(156); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_156] = [__v_0]; - record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[156].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_156] = [__v_8]; - record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[156].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14838,15 +14996,16 @@ const INPUT_SIZE_157: usize = 2; const IN_157: usize = 2; const OUT_157: usize = 1; fn aiur_fn_157( - inp: [G; IN_157], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(157); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14854,25 +15013,25 @@ fn aiur_fn_157( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_157] = [__v_7]; - record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[157].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[157].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i)?; } record.function_queries[157].output_at(__i).to_array::() }, _ => aiur_fn_157(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_157] = [__v_13]; - record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[157].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14886,19 +15045,20 @@ const INPUT_SIZE_158: usize = 6; const IN_158: usize = 6; const OUT_158: usize = 1; fn aiur_fn_158( - inp: [G; IN_158], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(158); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -14906,15 +15066,15 @@ fn aiur_fn_158( let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool((__v_11 == G::ZERO)); let __ret: [G; OUT_158] = [__v_12]; - record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[158].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -14923,7 +15083,7 @@ fn aiur_fn_158( match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_3, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_3, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 - __v_16); @@ -14931,21 +15091,21 @@ fn aiur_fn_158( if (__v_7 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[157].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i)?; } record.function_queries[157].output_at(__i).to_array::() }, _ => aiur_fn_157(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { @@ -14953,10 +15113,10 @@ fn aiur_fn_158( } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_4 + __v_29); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_158] = [__v_31]; - record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[158].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14977,57 +15137,58 @@ const INPUT_SIZE_159: usize = 32; const IN_159: usize = 32; const OUT_159: usize = 1; fn aiur_fn_159( - inp: [G; IN_159], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(159); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_35]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; break '__mc_0 [__v_36]; }, @@ -15037,18 +15198,18 @@ fn aiur_fn_159( } }; let __v_36: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_2, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_2, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = G::from_u64(1); - let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -15109,30 +15270,30 @@ fn aiur_fn_159( let __v_101: G = (__v_86 + __v_100); let __v_102: G = (__v_84 + __v_101); let __v_103: G = (__v_52 + __v_102); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_60, __v_6, __v_7, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_60, __v_6, __v_7, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(1); let __v_107: G = G::from_u64(1); - let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10, __v_108]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10, __v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_105, __v_109]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_105, __v_109]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_110, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_110, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = (__v_32 + __v_28); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_112, __v_113, __v_29, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_9, __v_116, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = (__v_119 - __v_32); let __v_121: G = G::from_bool((__v_120 == G::ZERO)); @@ -15140,16 +15301,16 @@ fn aiur_fn_159( if (__v_121 != __v_122) { return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = (__v_124 + __v_125); if (__v_123 != __v_126) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = (__v_127 - __v_32); let __v_129: G = G::from_bool((__v_128 == G::ZERO)); @@ -15157,29 +15318,29 @@ fn aiur_fn_159( if (__v_129 != __v_130) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = G::from_u64(1); if (__v_131 != __v_132) { return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None }); } let __v_133: G = G::from_u64(33); - let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_135: G = G::from_u64(1); if (__v_134 != __v_135) { return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_136: G = __r_arr[0]; let __v_137: G = G::from_u64(1); if (__v_136 != __v_137) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None }); } let __v_138: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; let __ret: [G; OUT_159] = [__v_139]; - record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[159].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15190,19 +15351,20 @@ const INPUT_SIZE_160: usize = 2; const IN_160: usize = 2; const OUT_160: usize = 1; fn aiur_fn_160( - inp: [G; IN_160], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(160); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[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_160] = [__v_4]; - record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[160].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15211,14 +15373,15 @@ const INPUT_SIZE_161: usize = 1; const IN_161: usize = 1; const OUT_161: usize = 1; fn aiur_fn_161( - inp: [G; IN_161], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(161); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -15227,11 +15390,11 @@ fn aiur_fn_161( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_161] = [__v_5]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -15242,14 +15405,14 @@ fn aiur_fn_161( let __v_10: G = G::from_bool((__v_3 == G::ZERO)); let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_161] = [__v_11]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_9]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15265,21 +15428,22 @@ const INPUT_SIZE_162: usize = 9; const IN_162: usize = 9; const OUT_162: usize = 1; fn aiur_fn_162( - inp: [G; IN_162], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(162); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); @@ -15288,16 +15452,16 @@ fn aiur_fn_162( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_162] = [__v_24]; - record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[162].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15306,55 +15470,56 @@ const INPUT_SIZE_163: usize = 33; const IN_163: usize = 33; const OUT_163: usize = 1; fn aiur_fn_163( - inp: [G; IN_163], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + record.checkpoint(163); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_163] = [__v_36]; - record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[163].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15363,26 +15528,27 @@ const INPUT_SIZE_164: usize = 2; const IN_164: usize = 2; const OUT_164: usize = 1; fn aiur_fn_164( - inp: [G; IN_164], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(164); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_164] = [__v_1]; - record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[164].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -15415,18 +15581,18 @@ fn aiur_fn_164( let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_164] = [__v_41]; - record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[164].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15440,22 +15606,23 @@ const INPUT_SIZE_165: usize = 2; const IN_165: usize = 2; const OUT_165: usize = 1; fn aiur_fn_165( - inp: [G; IN_165], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(165); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_165] = [__v_1]; - record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[165].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -15466,12 +15633,12 @@ fn aiur_fn_165( 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_165] = { let __args: [G; IN_165] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_13]; - record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[165].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15485,15 +15652,16 @@ const INPUT_SIZE_166: usize = 2; const IN_166: usize = 2; const OUT_166: usize = 10; fn aiur_fn_166( - inp: [G; IN_166], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(166); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -15533,7 +15701,7 @@ fn aiur_fn_166( let __v_36: G = G::from_u64(91); let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -15544,14 +15712,14 @@ fn aiur_fn_166( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -15586,78 +15754,78 @@ fn aiur_fn_166( let __v_87: G = __r_arr[31]; let __v_88: G = G::from_u64(1); let __v_89: G = G::from_u64(1); - let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_94: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = G::from_u64(1); let __v_100: G = G::from_u64(1); - let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_98, __v_101]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_98, __v_101]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_166] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126]; - record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[166].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15701,50 +15869,50 @@ fn aiur_fn_166( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_166] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; - record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[166].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15793,15 +15961,16 @@ const INPUT_SIZE_167: usize = 2; const IN_167: usize = 2; const OUT_167: usize = 10; fn aiur_fn_167( - inp: [G; IN_167], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + record.checkpoint(167); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, 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]; @@ -15830,11 +15999,11 @@ fn aiur_fn_167( match __v_26.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_167] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[167].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, 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]; @@ -15846,7 +16015,7 @@ fn aiur_fn_167( let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __ret: [G; OUT_167] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[167].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15857,15 +16026,16 @@ const INPUT_SIZE_168: usize = 2; const IN_168: usize = 2; const OUT_168: usize = 18; fn aiur_fn_168( - inp: [G; IN_168], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + record.checkpoint(168); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, 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]; @@ -15876,7 +16046,7 @@ fn aiur_fn_168( 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_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, 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]; @@ -15888,7 +16058,7 @@ fn aiur_fn_168( let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_168] = [__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]; - record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[168].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15897,25 +16067,26 @@ const INPUT_SIZE_169: usize = 2; const IN_169: usize = 2; const OUT_169: usize = 1; fn aiur_fn_169( - inp: [G; IN_169], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(169); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_169] = [__v_4]; - record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[169].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -15924,11 +16095,11 @@ fn aiur_fn_169( 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_169] = { let __args: [G; IN_169] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_169] = [__v_9]; - record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[169].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15944,16 +16115,17 @@ const INPUT_SIZE_170: usize = 3; const IN_170: usize = 3; const OUT_170: usize = 3; fn aiur_fn_170( - inp: [G; IN_170], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + record.checkpoint(170); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, 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]; @@ -15964,7 +16136,7 @@ fn aiur_fn_170( let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record)? }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; @@ -15973,7 +16145,7 @@ fn aiur_fn_170( let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record)? }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; @@ -15982,7 +16154,7 @@ fn aiur_fn_170( let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record)? }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; @@ -15991,7 +16163,7 @@ fn aiur_fn_170( let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record)? }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; @@ -16002,19 +16174,19 @@ fn aiur_fn_170( let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_51, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_51, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_52, __v_11, __v_12]; - record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[170].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16023,30 +16195,31 @@ const INPUT_SIZE_171: usize = 9; const IN_171: usize = 9; const OUT_171: usize = 1; fn aiur_fn_171( - inp: [G; IN_171], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = 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]; + record.checkpoint(171); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_13]; - record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[171].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16055,23 +16228,24 @@ const INPUT_SIZE_172: usize = 2; const IN_172: usize = 2; const OUT_172: usize = 1; fn aiur_fn_172( - inp: [G; IN_172], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(172); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_6]; - record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[172].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16080,13 +16254,14 @@ const INPUT_SIZE_173: usize = 1; const IN_173: usize = 1; const OUT_173: usize = 1; fn aiur_fn_173( - inp: [G; IN_173], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(173); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(0); @@ -16115,22 +16290,22 @@ fn aiur_fn_173( let __v_26: G = G::from_u64(118); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(48); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_173] = [__v_42]; - record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[173].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16139,15 +16314,16 @@ const INPUT_SIZE_174: usize = 2; const IN_174: usize = 2; const OUT_174: usize = 1; fn aiur_fn_174( - inp: [G; IN_174], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(174); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16161,16 +16337,16 @@ fn aiur_fn_174( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_174] = [__v_1]; - record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[174].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_174] = [__v_13]; - record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[174].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16184,26 +16360,27 @@ const INPUT_SIZE_175: usize = 2; const IN_175: usize = 2; const OUT_175: usize = 1; fn aiur_fn_175( - inp: [G; IN_175], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(175); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_175] = [__v_4]; - record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[175].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_175] = [__v_1]; - record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[175].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16217,30 +16394,31 @@ const INPUT_SIZE_176: usize = 9; const IN_176: usize = 9; const OUT_176: usize = 9; fn aiur_fn_176( - inp: [G; IN_176], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + record.checkpoint(176); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, 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); @@ -16270,24 +16448,24 @@ fn aiur_fn_176( let __v_39: G = G::from_u64(118); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(48); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_55, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_55, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16308,17 +16486,17 @@ fn aiur_fn_176( let __v_76: G = __r_arr[17]; let __v_77: G = G::from_u64(1); let __v_78: G = G::from_u64(1); - let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_75, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_75, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __v_84: G = G::from_u64(1); - let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_82, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_82, __v_85]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16339,26 +16517,26 @@ fn aiur_fn_176( let __v_103: G = __r_arr[17]; let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_108: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_102, __v_108]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_102, __v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_109, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_109, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); let __v_112: G = G::from_u64(1); - let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_8, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_8, __v_113]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_110, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_110, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(1); let __v_117: G = G::from_u64(1); - let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_115, __v_118]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_115, __v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16377,12 +16555,12 @@ fn aiur_fn_176( 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_172] = { let __args: [G; IN_172] = [__v_135, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_135, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = G::from_u64(1); let __v_139: G = G::from_u64(1); - let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_137, __v_140]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_137, __v_140]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16570,7 +16748,7 @@ fn aiur_fn_176( let __v_325: G = (__v_307 + __v_324); let __v_326: G = (__v_149 + __v_325); let __ret: [G; OUT_176] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157]; - record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[176].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16579,19 +16757,20 @@ const INPUT_SIZE_177: usize = 3; const IN_177: usize = 3; const OUT_177: usize = 2; fn aiur_fn_177( - inp: [G; IN_177], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(177); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_177] = [__v_0, __v_1]; - record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[177].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16605,11 +16784,11 @@ fn aiur_fn_177( 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_177] = { let __args: [G; IN_177] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_7, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_13, __v_14]; - record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[177].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16620,34 +16799,35 @@ const INPUT_SIZE_178: usize = 1; const IN_178: usize = 1; const OUT_178: usize = 1; fn aiur_fn_178( - inp: [G; IN_178], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(178); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_178] = [__v_1]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_178] = [__v_1]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !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_178] = { let __args: [G; IN_178] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); let __ret: [G; OUT_178] = [__v_4]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16658,16 +16838,17 @@ const INPUT_SIZE_179: usize = 3; const IN_179: usize = 3; const OUT_179: usize = 2; fn aiur_fn_179( - inp: [G; IN_179], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + record.checkpoint(179); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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); @@ -16675,7 +16856,7 @@ fn aiur_fn_179( let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); let __ret: [G; OUT_179] = [__v_7, __v_8]; - record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[179].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16684,29 +16865,30 @@ const INPUT_SIZE_180: usize = 1; const IN_180: usize = 1; const OUT_180: usize = 1; fn aiur_fn_180( - inp: [G; IN_180], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(180); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_1]; - record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[180].finish_prehashed(&inp, &__ret[..], !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_180] = { let __args: [G; IN_180] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[180].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i)?; } record.function_queries[180].output_at(__i).to_array::() }, _ => aiur_fn_180(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_180] = [__v_5]; - record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[180].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16717,23 +16899,24 @@ const INPUT_SIZE_181: usize = 3; const IN_181: usize = 3; const OUT_181: usize = 8; fn aiur_fn_181( - inp: [G; IN_181], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + record.checkpoint(181); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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_178] = { let __args: [G; IN_178] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -16845,7 +17028,7 @@ fn aiur_fn_181( let __v_93: G = (__v_92 - __v_8); let __v_94: G = (__v_93 * __v_83); let __ret: [G; OUT_181] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; - record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[181].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16854,61 +17037,62 @@ const INPUT_SIZE_182: usize = 24; const IN_182: usize = 24; const OUT_182: usize = 1; fn aiur_fn_182( - inp: [G; IN_182], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; + record.checkpoint(182); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_bool((__v_24 == G::ZERO)); let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; if (__v_27 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; if (__v_28 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; if (__v_29 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { @@ -16916,7 +17100,7 @@ fn aiur_fn_182( } let __v_32: G = G::from_u64(1); let __ret: [G; OUT_182] = [__v_32]; - record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[182].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16927,18 +17111,19 @@ const INPUT_SIZE_183: usize = 6; const IN_183: usize = 6; const OUT_183: usize = 2; fn aiur_fn_183( - inp: [G; IN_183], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(183); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = (__v_0 * __v_2); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_1 * __v_3); @@ -16950,7 +17135,7 @@ fn aiur_fn_183( let __v_14: G = (__v_10 + __v_4); let __v_15: G = (__v_13 + __v_5); let __ret: [G; OUT_183] = [__v_14, __v_15]; - record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[183].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16959,16 +17144,17 @@ const INPUT_SIZE_184: usize = 4; const IN_184: usize = 4; const OUT_184: usize = 2; fn aiur_fn_184( - inp: [G; IN_184], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(184); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 * __v_4); @@ -16982,7 +17168,7 @@ fn aiur_fn_184( let __v_14: G = (__v_0 + __v_10); let __v_15: G = (__v_1 + __v_13); let __ret: [G; OUT_184] = [__v_14, __v_15]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[184].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16991,14 +17177,15 @@ const INPUT_SIZE_185: usize = 1; const IN_185: usize = 1; const OUT_185: usize = 1; fn aiur_fn_185( - inp: [G; IN_185], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(185); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -17007,13 +17194,13 @@ fn aiur_fn_185( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_185] = [__v_7]; - record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[185].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -17021,14 +17208,14 @@ fn aiur_fn_185( match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_2, __v_3, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[184].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i)?; } record.function_queries[184].output_at(__i).to_array::() }, _ => aiur_fn_184(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[185].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i)?; } record.function_queries[185].output_at(__i).to_array::() }, _ => aiur_fn_185(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_185] = [__v_13]; - record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[185].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17047,28 +17234,29 @@ const INPUT_SIZE_186: usize = 15; const IN_186: usize = 15; const OUT_186: usize = 2; fn aiur_fn_186( - inp: [G; IN_186], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; + record.checkpoint(186); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[251].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i)?; } record.function_queries[251].output_at(__i).to_array::() }, _ => aiur_fn_251(__key, 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]; @@ -17077,7 +17265,7 @@ fn aiur_fn_186( 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_186] = [__v_16, __v_19]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -17085,109 +17273,109 @@ fn aiur_fn_186( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_4, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_5, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_6, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_7, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_19, __v_20]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_186] = [__v_9, __v_10]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_186] = [__v_11, __v_12]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_186] = [__v_13, __v_14]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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_186] = [__v_23, __v_24]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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_186] = [__v_23, __v_24]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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); @@ -17199,11 +17387,11 @@ fn aiur_fn_186( let __v_29: G = (__v_20 * __v_21); let __v_30: G = (__v_28 + __v_29); let __ret: [G; OUT_186] = [__v_27, __v_30]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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); @@ -17211,7 +17399,7 @@ fn aiur_fn_186( let __v_23: G = G::from_u64(0); let __v_24: G = (__v_23 - __v_20); let __ret: [G; OUT_186] = [__v_22, __v_24]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17225,53 +17413,54 @@ const INPUT_SIZE_187: usize = 19; const IN_187: usize = 19; const OUT_187: usize = 2; fn aiur_fn_187( - inp: [G; IN_187], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(187); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_187] = [__v_0, __v_1]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[187].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_26, __v_27]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[187].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17285,20 +17474,21 @@ const INPUT_SIZE_188: usize = 8; const IN_188: usize = 8; const OUT_188: usize = 4; fn aiur_fn_188( - inp: [G; IN_188], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(188); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = (__v_0 * __v_4); let __v_9: G = G::from_u64(7); let __v_10: G = (__v_1 * __v_5); @@ -17346,7 +17536,7 @@ fn aiur_fn_188( let __v_52: G = (__v_38 + __v_46); let __v_53: G = (__v_41 + __v_49); let __ret: [G; OUT_188] = [__v_50, __v_51, __v_52, __v_53]; - record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[188].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -17355,32 +17545,33 @@ const INPUT_SIZE_189: usize = 19; const IN_189: usize = 19; const OUT_189: usize = 4; fn aiur_fn_189( - inp: [G; IN_189], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(189); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -17391,27 +17582,27 @@ fn aiur_fn_189( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_189] = [__v_22, __v_23, __v_24, __v_25]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[189].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i)?; } record.function_queries[189].output_at(__i).to_array::() }, _ => aiur_fn_189(__key, 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_188] = { let __args: [G; IN_188] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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_186] = { let __args: [G; IN_186] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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_189] = [__v_32, __v_33, __v_28, __v_29]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17425,57 +17616,58 @@ const INPUT_SIZE_190: usize = 44; const IN_190: usize = 44; const OUT_190: usize = 2; fn aiur_fn_190( - inp: [G; IN_190], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(190); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -17483,13 +17675,13 @@ fn aiur_fn_190( match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_190] = [__v_0, __v_1]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[189].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i)?; } record.function_queries[189].output_at(__i).to_array::() }, _ => aiur_fn_189(__key, 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]; @@ -17498,10 +17690,10 @@ fn aiur_fn_190( 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_186] = { let __args: [G; IN_186] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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]; @@ -17526,7 +17718,7 @@ fn aiur_fn_190( 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_188] = { let __args: [G; IN_188] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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]; @@ -17537,23 +17729,23 @@ fn aiur_fn_190( match __v_88.as_canonical_u64() { 0u64 => { let __v_89: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_89]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_89]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_35, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_36, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_36, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_36, __v_102]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_36, __v_102]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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); @@ -17562,23 +17754,23 @@ fn aiur_fn_190( 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_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_183] = { let __args: [G; IN_183] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_121, __v_122]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17587,44 +17779,44 @@ fn aiur_fn_190( match __v_90.as_canonical_u64() { 0u64 => { let __v_91: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_91]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_35, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_35, __v_101]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_101]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_35, __v_106]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_35, __v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_183] = { let __args: [G; IN_183] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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); @@ -17639,11 +17831,11 @@ fn aiur_fn_190( 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_190] = { let __args: [G; IN_190] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_137, __v_138]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17651,11 +17843,11 @@ fn aiur_fn_190( 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_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_95, __v_96]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -17675,43 +17867,44 @@ const INPUT_SIZE_191: usize = 28; const IN_191: usize = 28; const OUT_191: usize = 2; fn aiur_fn_191( - inp: [G; IN_191], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; + record.checkpoint(191); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, 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); @@ -17760,7 +17953,7 @@ fn aiur_fn_191( let __v_75: G = (__v_21 * __v_69); let __v_76: G = (__v_22 * __v_66); let __v_77: G = (__v_75 + __v_76); - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_78: G = __loaded[0]; let __v_79: G = __loaded[1]; let __v_80: G = __loaded[2]; @@ -17768,42 +17961,42 @@ fn aiur_fn_191( match __v_78.as_canonical_u64() { 1u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_9, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_9, __v_82]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_8, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_85]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_183] = { let __args: [G; IN_183] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_253] = { let __args: [G; IN_253] = [__v_9, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_9, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_8, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_8, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_183] = { let __args: [G; IN_183] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_104, __v_105]; - record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, 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); @@ -17814,11 +18007,11 @@ fn aiur_fn_191( 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_190] = { let __args: [G; IN_190] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_93, __v_94]; - record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17832,20 +18025,21 @@ const INPUT_SIZE_192: usize = 8; const IN_192: usize = 8; const OUT_192: usize = 1; fn aiur_fn_192( - inp: [G; IN_192], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(192); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); @@ -17864,17 +18058,17 @@ fn aiur_fn_192( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_192] = [__v_34]; - record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[192].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -17883,18 +18077,19 @@ const INPUT_SIZE_193: usize = 5; const IN_193: usize = 5; const OUT_193: usize = 2; fn aiur_fn_193( - inp: [G; IN_193], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(193); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -17904,7 +18099,7 @@ fn aiur_fn_193( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_9, __v_10]; - record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[193].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -17924,13 +18119,13 @@ fn aiur_fn_193( 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_193] = { let __args: [G; IN_193] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[193].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i)?; } record.function_queries[193].output_at(__i).to_array::() }, _ => aiur_fn_193(__key, 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_193] = [__v_27, __v_28]; - record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[193].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17944,126 +18139,127 @@ const INPUT_SIZE_194: usize = 1; const IN_194: usize = 1; const OUT_194: usize = 1; fn aiur_fn_194( - inp: [G; IN_194], + inp: QueryKey, 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]; + record.checkpoint(194); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -18074,26 +18270,27 @@ const INPUT_SIZE_195: usize = 4; const IN_195: usize = 4; const OUT_195: usize = 2; fn aiur_fn_195( - inp: [G; IN_195], + inp: QueryKey, 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 __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(195); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_195] = [__v_6, __v_9]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -18101,25 +18298,25 @@ fn aiur_fn_195( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_195] = [__v_6, __v_9]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_6, __v_8]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -18138,33 +18335,34 @@ const INPUT_SIZE_196: usize = 20; const IN_196: usize = 20; const OUT_196: usize = 1; fn aiur_fn_196( - inp: [G; IN_196], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + record.checkpoint(196); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -18177,46 +18375,46 @@ fn aiur_fn_196( 1u64 => { let __v_28: G = G::from_u64(1); let __ret: [G; OUT_196] = [__v_28]; - record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[196].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[194].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i)?; } record.function_queries[194].output_at(__i).to_array::() }, _ => aiur_fn_194(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_32, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() { 0u64 => { let __v_44: G = G::from_u64(1); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_46, __v_49]; }, 1u64 => { @@ -18224,20 +18422,20 @@ fn aiur_fn_196( 0u64 => { let __v_44: G = G::from_u64(1); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_7, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_44, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -18253,14 +18451,14 @@ fn aiur_fn_196( }; let __v_44: G = __mc_out___mc_0[0]; let __v_45: G = __mc_out___mc_0[1]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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_178] = { let __args: [G; IN_178] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -18389,18 +18587,18 @@ fn aiur_fn_196( let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(1); let __v_155: G = G::from_u64(1); - let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[180].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i)?; } record.function_queries[180].output_at(__i).to_array::() }, _ => aiur_fn_180(__key, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -18419,7 +18617,7 @@ fn aiur_fn_196( } let __v_176: G = G::from_u64(0); let __v_177: G = G::from_u64(0); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, 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); @@ -18468,7 +18666,7 @@ fn aiur_fn_196( let __v_223: G = (__v_114 * __v_217); let __v_224: G = (__v_117 * __v_214); let __v_225: G = (__v_223 + __v_224); - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_226: G = __loaded[0]; let __v_227: G = __loaded[1]; let __v_228: G = __loaded[2]; @@ -18476,40 +18674,40 @@ fn aiur_fn_196( 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_253] = { let __args: [G; IN_253] = [__v_41, __v_230]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_41, __v_230]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_39, __v_233]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_39, __v_233]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_183] = { let __args: [G; IN_183] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_253] = { let __args: [G; IN_253] = [__v_41, __v_242]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_41, __v_242]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_253] = { let __args: [G; IN_253] = [__v_39, __v_245]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_39, __v_245]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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_183] = { let __args: [G; IN_183] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_246] = { let __args: [G; IN_246] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, 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); @@ -18520,7 +18718,7 @@ fn aiur_fn_196( 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_190] = { let __args: [G; IN_190] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, 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]; @@ -18532,19 +18730,19 @@ fn aiur_fn_196( }; let __v_230: G = __mc_out___mc_1[0]; let __v_231: G = __mc_out___mc_1[1]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_232: G = __r_arr[0]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_232, __v_233]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_232, __v_233]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_234: G = __r_arr[0]; - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_234]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_234]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[185].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i)?; } record.function_queries[185].output_at(__i).to_array::() }, _ => aiur_fn_185(__key, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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_193] = { let __args: [G; IN_193] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[193].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i)?; } record.function_queries[193].output_at(__i).to_array::() }, _ => aiur_fn_193(__key, 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); @@ -18556,12 +18754,12 @@ fn aiur_fn_196( let __v_248: G = (__v_231 * __v_134); let __v_249: G = (__v_247 + __v_248); let __v_250: G = G::from_u64(32); - let __v_251: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record) }; + let __v_251: G = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_250)?; Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record)? }; let __v_252: G = G::from_u64(1); if (__v_251 != __v_252) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_235]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_235]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, 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)); @@ -18580,10 +18778,10 @@ fn aiur_fn_196( } let __v_263: G = G::from_u64(1); let __v_264: G = (__v_9 + __v_263); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_265: G = __r_arr[0]; let __ret: [G; OUT_196] = [__v_265]; - record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[196].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -18599,16 +18797,17 @@ const INPUT_SIZE_197: usize = 3; const IN_197: usize = 3; const OUT_197: usize = 2; fn aiur_fn_197( - inp: [G; IN_197], + inp: QueryKey, 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 = inp[2]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(197); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -18624,7 +18823,7 @@ fn aiur_fn_197( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_197] = [__v_13, __v_14]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[197].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -18650,7 +18849,7 @@ fn aiur_fn_197( 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_197] = { let __args: [G; IN_197] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[197].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i)?; } record.function_queries[197].output_at(__i).to_array::() }, _ => aiur_fn_197(__key, 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); @@ -18664,7 +18863,7 @@ fn aiur_fn_197( let __v_45: G = (__v_33 + __v_41); let __v_46: G = (__v_34 + __v_44); let __ret: [G; OUT_197] = [__v_45, __v_46]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[197].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -18678,31 +18877,32 @@ const INPUT_SIZE_198: usize = 7; const IN_198: usize = 7; const OUT_198: usize = 2; fn aiur_fn_198( - inp: [G; IN_198], + inp: QueryKey, 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 = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(198); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_198] = [__v_0, __v_1]; - record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[198].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[197].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i)?; } record.function_queries[197].output_at(__i).to_array::() }, _ => aiur_fn_197(__key, 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); @@ -18732,11 +18932,11 @@ fn aiur_fn_198( 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_198] = { let __args: [G; IN_198] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_33, __v_34]; - record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[198].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -18750,59 +18950,60 @@ const INPUT_SIZE_199: usize = 38; const IN_199: usize = 38; const OUT_199: usize = 1; fn aiur_fn_199( - inp: [G; IN_199], + inp: QueryKey, 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 = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; + record.checkpoint(199); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { @@ -18810,7 +19011,7 @@ fn aiur_fn_199( 0u64 => { let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_42]; }, 1u64 => { @@ -18822,15 +19023,15 @@ fn aiur_fn_199( } }; let __v_40: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_17, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_17, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_13, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_13, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_12, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_12, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(109); @@ -18860,24 +19061,24 @@ fn aiur_fn_199( let __v_71: G = G::from_u64(118); let __v_72: G = G::from_u64(0); let __v_73: G = G::from_u64(48); - let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __v_76]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __v_85]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_88: G = G::from_u64(1); let __v_89: G = G::from_u64(1); - let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_87, __v_90]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; @@ -18898,17 +19099,17 @@ fn aiur_fn_199( let __v_108: G = __r_arr[17]; let __v_109: G = G::from_u64(1); let __v_110: G = G::from_u64(1); - let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_107, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_107, __v_113]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(1); let __v_116: G = G::from_u64(1); - let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_114, __v_117]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_114, __v_117]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = __r_arr[2]; @@ -18929,26 +19130,26 @@ fn aiur_fn_199( let __v_135: G = __r_arr[17]; let __v_136: G = G::from_u64(1); let __v_137: G = G::from_u64(1); - let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_140: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_134, __v_140]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_134, __v_140]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_141, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_141, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_142: G = __r_arr[0]; let __v_143: G = G::from_u64(1); let __v_144: G = G::from_u64(1); - let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16, __v_145]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16, __v_145]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_146: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_142, __v_146]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_142, __v_146]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_147: G = __r_arr[0]; let __v_148: G = G::from_u64(1); let __v_149: G = G::from_u64(1); - let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_147, __v_150]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_147, __v_150]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; @@ -18967,12 +19168,12 @@ fn aiur_fn_199( let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_167, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_167, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_169: G = __r_arr[0]; let __v_170: G = G::from_u64(1); let __v_171: G = G::from_u64(1); - let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_169, __v_172]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_169, __v_172]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -19161,27 +19362,27 @@ fn aiur_fn_199( let __v_358: G = (__v_181 + __v_357); let __v_359: G = G::from_u64(0); let __v_360: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_361: G = __r_arr[0]; let __v_362: G = __r_arr[1]; let __v_363: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); let __v_368: G = G::from_u64(1); - let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_32.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_369]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_33, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_33, __v_369]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_370: G = __r_arr[0]; break '__mc_1 [__v_370]; }, @@ -19191,18 +19392,18 @@ fn aiur_fn_199( } }; let __v_370: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_31, __v_370]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_31, __v_370]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_371: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_35, __v_371]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_35, __v_371]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_372: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_34, __v_372]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_34, __v_372]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_373: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_189, __v_373]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_189, __v_373]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_374: G = __r_arr[0]; let __v_375: G = G::from_u64(1); let __v_376: G = G::from_u64(1); - let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_374, __v_377]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_374, __v_377]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_378: G = __r_arr[0]; let __v_379: G = __r_arr[1]; let __v_380: G = __r_arr[2]; @@ -19263,28 +19464,28 @@ fn aiur_fn_199( let __v_435: G = (__v_420 + __v_434); let __v_436: G = (__v_418 + __v_435); let __v_437: G = (__v_386 + __v_436); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_394, __v_18, __v_19, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_438: G = __r_arr[0]; let __v_439: G = __r_arr[1]; let __v_440: G = G::from_u64(1); let __v_441: G = G::from_u64(1); - let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_22, __v_442]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_22, __v_442]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_443: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_439, __v_443]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_439, __v_443]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_444: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_444, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_444, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_445: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_446: G = __r_arr[0]; let __v_447: G = __r_arr[1]; let __v_448: G = (__v_366 + __v_0); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_446, __v_447, __v_4, __v_448]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_449: G = __r_arr[0]; let __v_450: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_20, __v_21, __v_450, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_451: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_452: G = __r_arr[0]; let __v_453: G = G::from_u64(0); if (__v_1 != __v_453) { @@ -19298,15 +19499,15 @@ fn aiur_fn_199( if (__v_3 != __v_455) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; let __v_457: G = G::from_u64(1); if (__v_456 != __v_457) { return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_458: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_459: G = __r_arr[0]; let __v_460: G = (__v_458 - __v_459); let __v_461: G = G::from_bool((__v_460 == G::ZERO)); @@ -19314,9 +19515,9 @@ fn aiur_fn_199( if (__v_461 != __v_462) { return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_463: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_464: G = __r_arr[0]; let __v_465: G = (__v_463 - __v_464); let __v_466: G = G::from_bool((__v_465 == G::ZERO)); @@ -19324,7 +19525,7 @@ fn aiur_fn_199( 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_250] = { let __args: [G; IN_250] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_468: G = __r_arr[0]; let __v_469: G = (__v_468 - __v_366); let __v_470: G = G::from_bool((__v_469 == G::ZERO)); @@ -19332,16 +19533,16 @@ fn aiur_fn_199( if (__v_470 != __v_471) { return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_472: G = __r_arr[0]; let __v_473: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_474: G = __r_arr[0]; let __v_475: G = (__v_473 + __v_474); if (__v_472 != __v_475) { return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_476: G = __r_arr[0]; let __v_477: G = (__v_476 - __v_366); let __v_478: G = G::from_bool((__v_477 == G::ZERO)); @@ -19349,29 +19550,29 @@ fn aiur_fn_199( if (__v_478 != __v_479) { return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_480: G = __r_arr[0]; let __v_481: G = G::from_u64(1); if (__v_480 != __v_481) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None }); } let __v_482: G = G::from_u64(33); - let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_484: G = G::from_u64(1); if (__v_483 != __v_484) { return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_485: G = __r_arr[0]; let __v_486: G = G::from_u64(1); if (__v_485 != __v_486) { return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); } let __v_487: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_488: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_488]; - record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[199].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19390,14 +19591,15 @@ const INPUT_SIZE_200: usize = 1; const IN_200: usize = 1; const OUT_200: usize = 1; fn aiur_fn_200( - inp: [G; IN_200], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(200); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19405,7 +19607,7 @@ fn aiur_fn_200( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_4]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[200].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -19416,10 +19618,10 @@ fn aiur_fn_200( 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_200] = { let __args: [G; IN_200] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_8]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[200].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19433,15 +19635,16 @@ const INPUT_SIZE_201: usize = 2; const IN_201: usize = 2; const OUT_201: usize = 1; fn aiur_fn_201( - inp: [G; IN_201], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + record.checkpoint(201); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -19454,13 +19657,13 @@ fn aiur_fn_201( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_201] = [__v_12]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -19468,19 +19671,19 @@ fn aiur_fn_201( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_201] = [__v_13]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_201] = [__v_15]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19501,15 +19704,16 @@ const INPUT_SIZE_202: usize = 2; const IN_202: usize = 2; const OUT_202: usize = 1; fn aiur_fn_202( - inp: [G; IN_202], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(202); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -19518,13 +19722,13 @@ fn aiur_fn_202( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_202] = [__v_8]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -19532,19 +19736,19 @@ fn aiur_fn_202( 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_9]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_202] = [__v_11]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19565,21 +19769,22 @@ const INPUT_SIZE_203: usize = 1; const IN_203: usize = 1; const OUT_203: usize = 2; fn aiur_fn_203( - inp: [G; IN_203], + inp: QueryKey, 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + record.checkpoint(203); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_203] = [__v_3, __v_4]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -19588,39 +19793,40 @@ const INPUT_SIZE_204: usize = 2; const IN_204: usize = 2; const OUT_204: usize = 2; fn aiur_fn_204( - inp: [G; IN_204], + inp: QueryKey, 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 __v_1: G = inp[1]; + record.checkpoint(204); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_204] = [__v_4, __v_0]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, 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_204] = { let __args: [G; IN_204] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_204] = [__v_11, __v_9]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19631,21 +19837,22 @@ const INPUT_SIZE_205: usize = 1; const IN_205: usize = 1; const OUT_205: usize = 2; fn aiur_fn_205( - inp: [G; IN_205], + inp: QueryKey, 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + record.checkpoint(205); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_205] = [__v_3, __v_4]; - record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -19654,25 +19861,26 @@ const INPUT_SIZE_206: usize = 2; const IN_206: usize = 2; const OUT_206: usize = 2; fn aiur_fn_206( - inp: [G; IN_206], + inp: QueryKey, 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 __v_1: G = inp[1]; + record.checkpoint(206); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_206] = [__v_4, __v_0]; - record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[26].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i)?; } record.function_queries[26].output_at(__i).to_array::() }, _ => aiur_fn_26(__key, 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]; @@ -19684,13 +19892,13 @@ fn aiur_fn_206( 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_206] = { let __args: [G; IN_206] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_206] = [__v_16, __v_14]; - record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19701,208 +19909,209 @@ const INPUT_SIZE_207: usize = 1; const IN_207: usize = 1; const OUT_207: usize = 2; fn aiur_fn_207( - inp: [G; IN_207], + inp: QueryKey, 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; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(207); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_207] = [__v_97, __v_96]; - record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[207].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20071,15 +20280,16 @@ const INPUT_SIZE_208: usize = 2; const IN_208: usize = 2; const OUT_208: usize = 1; fn aiur_fn_208( - inp: [G; IN_208], + inp: QueryKey, 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]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(208); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -20113,71 +20323,71 @@ fn aiur_fn_208( let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_96: G = G::from_u64(0); - let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_208] = [__v_97]; - record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[208].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20186,14 +20396,15 @@ const INPUT_SIZE_209: usize = 1; const IN_209: usize = 1; const OUT_209: usize = 8; fn aiur_fn_209( - inp: [G; IN_209], + inp: QueryKey, 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 __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(209); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -20299,7 +20510,7 @@ fn aiur_fn_209( let __v_103: G = (__v_97 + __v_102); let __v_104: G = (__v_29 + __v_103); let __ret: [G; OUT_209] = [__v_41, __v_50, __v_59, __v_68, __v_77, __v_86, __v_95, __v_104]; - record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[209].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20308,28 +20519,29 @@ const INPUT_SIZE_210: usize = 2; const IN_210: usize = 2; const OUT_210: usize = 1; fn aiur_fn_210( - inp: [G; IN_210], + inp: QueryKey, 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]; + record.checkpoint(210); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_10]; - record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[210].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20338,25 +20550,26 @@ const INPUT_SIZE_211: usize = 1; const IN_211: usize = 1; const OUT_211: usize = 1; fn aiur_fn_211( - inp: [G; IN_211], + inp: QueryKey, 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]; + record.checkpoint(211); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_8]; - record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[211].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20365,16 +20578,17 @@ const INPUT_SIZE_212: usize = 4; const IN_212: usize = 4; const OUT_212: usize = 1; fn aiur_fn_212( - inp: [G; IN_212], + inp: QueryKey, 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 __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(212); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[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); @@ -20385,7 +20599,7 @@ fn aiur_fn_212( let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_11 + __v_3); let __ret: [G; OUT_212] = [__v_12]; - record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[212].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20394,15 +20608,16 @@ const INPUT_SIZE_213: usize = 2; const IN_213: usize = 2; const OUT_213: usize = 1; fn aiur_fn_213( - inp: [G; IN_213], + inp: QueryKey, 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 __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(213); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -20435,7 +20650,7 @@ fn aiur_fn_213( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -20638,22 +20853,22 @@ fn aiur_fn_213( 0u64 => { let __v_218: G = G::from_u64(1); let __ret: [G; OUT_213] = [__v_218]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !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 }; + 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_213] = [__v_219]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_219: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_219]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20661,18 +20876,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_200]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_200: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_200]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20680,18 +20895,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_181]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_181: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_181]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20699,18 +20914,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_162]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_162: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_162]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20718,18 +20933,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_143]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_143: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_143]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20737,18 +20952,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_124]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_124: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_124]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20756,18 +20971,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_105]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_105: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_105]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20775,18 +20990,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_86]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_86: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_86]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20799,44 +21014,45 @@ const INPUT_SIZE_214: usize = 1; const IN_214: usize = 1; const OUT_214: usize = 0; fn aiur_fn_214( - inp: [G; IN_214], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(214); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_214] = []; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_214] = []; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: tree leaves are not strictly sorted".to_string()) }); } - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[214].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i)?; } record.function_queries[214].output_at(__i).to_array::() }, _ => aiur_fn_214(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_214] = []; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20855,49 +21071,50 @@ const INPUT_SIZE_215: usize = 1; const IN_215: usize = 1; const OUT_215: usize = 2; fn aiur_fn_215( - inp: [G; IN_215], + inp: QueryKey, 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; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(215); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_215] = [__v_9, __v_4]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_215] = [__v_5, __v_2]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_7, __v_6]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20911,14 +21128,15 @@ const INPUT_SIZE_216: usize = 1; const IN_216: usize = 1; const OUT_216: usize = 1; fn aiur_fn_216( - inp: [G; IN_216], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(216); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -20926,20 +21144,20 @@ fn aiur_fn_216( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_216] = [__v_6]; - record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[216].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[216].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i)?; } record.function_queries[216].output_at(__i).to_array::() }, _ => aiur_fn_216(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_216] = [__v_7]; - record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[216].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20953,14 +21171,15 @@ const INPUT_SIZE_217: usize = 1; const IN_217: usize = 1; const OUT_217: usize = 1; fn aiur_fn_217( - inp: [G; IN_217], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(217); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -20968,13 +21187,13 @@ fn aiur_fn_217( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_217] = [__v_6]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -21012,27 +21231,27 @@ fn aiur_fn_217( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_217] = [__v_45]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[217].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i)?; } record.function_queries[217].output_at(__i).to_array::() }, _ => aiur_fn_217(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_217] = [__v_10]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21051,36 +21270,37 @@ const INPUT_SIZE_218: usize = 1; const IN_218: usize = 1; const OUT_218: usize = 1; fn aiur_fn_218( - inp: [G; IN_218], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(218); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_218] = [__v_2]; - record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[218].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[217].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i)?; } record.function_queries[217].output_at(__i).to_array::() }, _ => aiur_fn_217(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[218].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i)?; } record.function_queries[218].output_at(__i).to_array::() }, _ => aiur_fn_218(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_8]; - record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[218].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21096,19 +21316,20 @@ const INPUT_SIZE_219: usize = 1; const IN_219: usize = 1; const OUT_219: usize = 1; fn aiur_fn_219( - inp: [G; IN_219], + inp: QueryKey, 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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } }; + record.checkpoint(219); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[216].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i)?; } record.function_queries[216].output_at(__i).to_array::() }, _ => aiur_fn_216(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[218].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i)?; } record.function_queries[218].output_at(__i).to_array::() }, _ => aiur_fn_218(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_2]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[219].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -21117,14 +21338,15 @@ const INPUT_SIZE_220: usize = 1; const IN_220: usize = 1; const OUT_220: usize = 1; fn aiur_fn_220( - inp: [G; IN_220], + inp: QueryKey, 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; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(220); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -21162,22 +21384,22 @@ fn aiur_fn_220( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(5); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[214].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i)?; } record.function_queries[214].output_at(__i).to_array::() }, _ => aiur_fn_214(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[219].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i)?; } record.function_queries[219].output_at(__i).to_array::() }, _ => aiur_fn_219(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = G::from_u64(226); if (__v_38 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("aggr: tree has the wrong Ixon tag".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -21192,20 +21414,20 @@ fn aiur_fn_220( if (__v_46 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("aggr: trailing bytes after AssumptionTree".to_string()) }); } - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("aggr: a present tree must contain at least one leaf".to_string()) }); } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_42, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_42, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64(), msg: Some("aggr: tree leaves do not reproduce the canonical root".to_string()) }); } let __ret: [G; OUT_220] = [__v_40]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[220].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -21214,28 +21436,29 @@ const INPUT_SIZE_221: usize = 2; const IN_221: usize = 2; const OUT_221: usize = 1; fn aiur_fn_221( - inp: [G; IN_221], + inp: QueryKey, 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]; + record.checkpoint(221); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_221] = [__v_4]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_2]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21249,19 +21472,20 @@ const INPUT_SIZE_222: usize = 2; const IN_222: usize = 2; const OUT_222: usize = 0; fn aiur_fn_222( - inp: [G; IN_222], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(222); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -21270,7 +21494,7 @@ fn aiur_fn_222( match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_222] = []; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21281,15 +21505,15 @@ fn aiur_fn_222( 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: set element mismatch".to_string()) }); } - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_222] = []; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21308,82 +21532,83 @@ const INPUT_SIZE_223: usize = 3; const IN_223: usize = 3; const OUT_223: usize = 0; fn aiur_fn_223( - inp: [G; IN_223], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(223); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_222] = { let __args: [G; IN_222] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_213] = { let __args: [G; IN_213] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: subject union mismatch".to_string()) }); } - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21409,19 +21634,20 @@ const INPUT_SIZE_224: usize = 2; const IN_224: usize = 2; const OUT_224: usize = 4; fn aiur_fn_224( - inp: [G; IN_224], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(224); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -21432,13 +21658,13 @@ fn aiur_fn_224( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __ret: [G; OUT_224] = [__v_8, __v_9, __v_9, __v_9]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_8, __v_6, __v_0, __v_7]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21451,29 +21677,29 @@ fn aiur_fn_224( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_8, __v_3, __v_4, __v_1]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, 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_224] = [__v_9, __v_3, __v_4, __v_1]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_9, __v_3, __v_4, __v_7]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_9, __v_6, __v_0, __v_7]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21494,15 +21720,16 @@ const INPUT_SIZE_225: usize = 2; const IN_225: usize = 2; const OUT_225: usize = 2; fn aiur_fn_225( - inp: [G; IN_225], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(225); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -21510,31 +21737,31 @@ fn aiur_fn_225( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_5, __v_1]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[225].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i)?; } record.function_queries[225].output_at(__i).to_array::() }, _ => aiur_fn_225(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_225] = [__v_6, __v_7]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_6, __v_4]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_6, __v_1]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21550,24 +21777,25 @@ const INPUT_SIZE_226: usize = 4; const IN_226: usize = 4; const OUT_226: usize = 0; fn aiur_fn_226( - inp: [G; IN_226], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; + record.checkpoint(226); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[224].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i)?; } record.function_queries[224].output_at(__i).to_array::() }, _ => aiur_fn_224(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -21583,36 +21811,36 @@ fn aiur_fn_226( return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_226] = []; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[225].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i)?; } record.function_queries[225].output_at(__i).to_array::() }, _ => aiur_fn_225(__key, 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_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_226] = []; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("aggr: outstanding assumption mismatch".to_string()) }); } - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_226] = []; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21633,36 +21861,37 @@ const INPUT_SIZE_227: usize = 3; const IN_227: usize = 3; const OUT_227: usize = 2; fn aiur_fn_227( - inp: [G; IN_227], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(227); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_227] = [__v_0, __v_2]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[227].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, 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_210] = { let __args: [G; IN_210] = [__v_5, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -21670,18 +21899,18 @@ fn aiur_fn_227( }; 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_9: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_8)?; Bytes2::less_than(&__v_3, &__v_8) } else { bytes2_less_than_value(__v_3, __v_8, record)? }; let __v_10: G = G::from_u64(1); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("aggr structural: path side must be 0 or 1".to_string()) }); } let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_12, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[227].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i)?; } record.function_queries[227].output_at(__i).to_array::() }, _ => aiur_fn_227(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_227] = [__v_13, __v_14]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[227].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21692,16 +21921,17 @@ const INPUT_SIZE_228: usize = 2; const IN_228: usize = 2; const OUT_228: usize = 1; fn aiur_fn_228( - inp: [G; IN_228], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(228); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(6); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -21738,20 +21968,20 @@ fn aiur_fn_228( let __v_35: G = __io_pair.0; let __v_36: G = __io_pair.1; let __v_37: G = G::from_u64(6); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_37, __v_35, __v_36]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_37, __v_35, __v_36]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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_42: G = if unconstrained { Bytes2::validate_inputs(&__v_39, &__v_41)?; Bytes2::less_than(&__v_39, &__v_41) } else { bytes2_less_than_value(__v_39, __v_41, record)? }; let __v_43: G = G::from_u64(1); if (__v_42 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("aggr structural: discharge choice must be 0 or 1".to_string()) }); } match __v_39.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -21768,25 +21998,25 @@ fn aiur_fn_228( } let __v_49: G = G::from_u64(0); let __ret: [G; OUT_228] = [__v_49]; - record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[228].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_46, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_46, __v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[227].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i)?; } record.function_queries[227].output_at(__i).to_array::() }, _ => aiur_fn_227(__key, 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_50: G = if unconstrained { Bytes2::validate_inputs(&__v_44, &__v_49)?; Bytes2::less_than(&__v_44, &__v_49) } else { bytes2_less_than_value(__v_44, __v_49, record)? }; let __v_51: G = G::from_u64(1); if (__v_50 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("aggr structural: Merkle path exceeds 64 steps".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; @@ -21801,7 +22031,7 @@ fn aiur_fn_228( if (__v_54 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("aggr structural: trailing bytes after Merkle path".to_string()) }); } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_47, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_47, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(1); if (__v_57 != __v_58) { @@ -21809,7 +22039,7 @@ fn aiur_fn_228( } let __v_59: G = G::from_u64(1); let __ret: [G; OUT_228] = [__v_59]; - record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[228].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21820,24 +22050,25 @@ const INPUT_SIZE_229: usize = 4; const IN_229: usize = 4; const OUT_229: usize = 0; fn aiur_fn_229( - inp: [G; IN_229], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; + record.checkpoint(229); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[224].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i)?; } record.function_queries[224].output_at(__i).to_array::() }, _ => aiur_fn_224(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -21853,35 +22084,35 @@ fn aiur_fn_229( return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr structural: output has an extra assumption".to_string()) }); } let __ret: [G; OUT_229] = []; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_229] = []; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr structural: outstanding assumption mismatch".to_string()) }); } - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_229] = []; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21902,14 +22133,15 @@ const INPUT_SIZE_230: usize = 1; const IN_230: usize = 1; const OUT_230: usize = 3; fn aiur_fn_230( - inp: [G; IN_230], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(230); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -21917,16 +22149,16 @@ fn aiur_fn_230( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_3, __v_4, __v_2]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[230].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, 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_230] = [__v_5, __v_3, __v_4]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[230].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21940,20 +22172,21 @@ const INPUT_SIZE_231: usize = 1; const IN_231: usize = 1; const OUT_231: usize = 3; fn aiur_fn_231( - inp: [G; IN_231], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(231); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[230].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i)?; } record.function_queries[230].output_at(__i).to_array::() }, _ => aiur_fn_230(__key, 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]; @@ -21961,7 +22194,7 @@ fn aiur_fn_231( if (__v_1 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: claim is not CheckEnv".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -21977,7 +22210,7 @@ fn aiur_fn_231( return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) }); } let __ret: [G; OUT_231] = [__v_3, __v_5, __v_6]; - record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[231].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -21986,26 +22219,27 @@ const INPUT_SIZE_232: usize = 8; const IN_232: usize = 8; const OUT_232: usize = 1; fn aiur_fn_232( - inp: [G; IN_232], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(232); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(4); let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __v_11: G = G::from_u64(4); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -22041,7 +22275,7 @@ fn aiur_fn_232( let __v_44: G = G::from_u64(91); let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -22052,14 +22286,14 @@ fn aiur_fn_232( let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(0); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_59: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -22189,7 +22423,7 @@ fn aiur_fn_232( return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: claim preimage digest mismatch".to_string()) }); } let __ret: [G; OUT_232] = [__v_12]; - record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22198,15 +22432,16 @@ const INPUT_SIZE_233: usize = 2; const IN_233: usize = 2; const OUT_233: usize = 1; fn aiur_fn_233( - inp: [G; IN_233], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } }; + record.checkpoint(233); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[258].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i)?; } record.function_queries[258].output_at(__i).to_array::() }, _ => aiur_fn_258(__key, 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]; @@ -22237,7 +22472,7 @@ fn aiur_fn_233( let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_2 + __v_29); let __ret: [G; OUT_233] = [__v_30]; - record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[233].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22246,46 +22481,47 @@ const INPUT_SIZE_234: usize = 2; const IN_234: usize = 2; const OUT_234: usize = 8; fn aiur_fn_234( - inp: [G; IN_234], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + record.checkpoint(234); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[234].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22294,28 +22530,29 @@ const INPUT_SIZE_235: usize = 16; const IN_235: usize = 16; const OUT_235: usize = 0; fn aiur_fn_235( - inp: [G; IN_235], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(235); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; if (__v_0 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } @@ -22341,7 +22578,7 @@ fn aiur_fn_235( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_235] = []; - record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[235].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22350,20 +22587,21 @@ const INPUT_SIZE_236: usize = 1; const IN_236: usize = 1; const OUT_236: usize = 1; fn aiur_fn_236( - inp: [G; IN_236], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(236); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -22379,7 +22617,7 @@ fn aiur_fn_236( return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("aggr: child proof must expose exactly one claim".to_string()) }); } let __ret: [G; OUT_236] = [__v_2]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -22393,35 +22631,36 @@ const INPUT_SIZE_237: usize = 17; const IN_237: usize = 17; const OUT_237: usize = 12; fn aiur_fn_237( - inp: [G; IN_237], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(237); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; let __v_17: G = G::from_u64(1); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_0]; let __info = io_buffer.get_info(__v_17, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -22457,7 +22696,7 @@ fn aiur_fn_237( let __v_53: G = G::from_u64(91); let __v_54: G = G::from_u64(1); let __v_55: G = G::from_u64(1); - let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -22468,14 +22707,14 @@ fn aiur_fn_237( let __v_64: G = G::from_u64(0); let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -22582,16 +22821,16 @@ fn aiur_fn_237( let __v_176: G = (__v_101 + __v_175); let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_113, __v_122, __v_131, __v_140, __v_149, __v_158, __v_167, __v_176, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_113, __v_122, __v_131, __v_140, __v_149, __v_158, __v_167, __v_176, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_113, __v_122, __v_131, __v_140, __v_149, __v_158, __v_167, __v_176, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_113, __v_122, __v_131, __v_140, __v_149, __v_158, __v_167, __v_176, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_177: G = __r_arr[0]; let __v_178: G = __r_arr[1]; let __v_179: G = __r_arr[2]; @@ -22602,7 +22841,7 @@ fn aiur_fn_237( let __v_184: G = __r_arr[7]; let __v_185: G = __r_arr[8]; let __v_186: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_186]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_186]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_187: G = __r_arr[0]; let __v_188: G = __r_arr[1]; let __v_189: G = __r_arr[2]; @@ -22613,7 +22852,7 @@ fn aiur_fn_237( let __v_194: G = __r_arr[7]; let __v_195: G = __r_arr[8]; let __v_196: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_196]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_196]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_197: G = __r_arr[0]; let __v_198: G = __r_arr[1]; let __v_199: G = __r_arr[2]; @@ -22624,7 +22863,7 @@ fn aiur_fn_237( let __v_204: G = __r_arr[7]; let __v_205: G = __r_arr[8]; let __v_206: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_206]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_206]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -22635,7 +22874,7 @@ fn aiur_fn_237( let __v_214: G = __r_arr[7]; let __v_215: G = __r_arr[8]; let __v_216: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_216]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_216]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_217: G = __r_arr[0]; let __v_218: G = __r_arr[1]; let __v_219: G = __r_arr[2]; @@ -22646,7 +22885,7 @@ fn aiur_fn_237( let __v_224: G = __r_arr[7]; let __v_225: G = __r_arr[8]; let __v_226: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_226]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_226]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_227: G = __r_arr[0]; let __v_228: G = __r_arr[1]; let __v_229: G = __r_arr[2]; @@ -22657,7 +22896,7 @@ fn aiur_fn_237( let __v_234: G = __r_arr[7]; let __v_235: G = __r_arr[8]; let __v_236: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_236]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_236]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_237: G = __r_arr[0]; let __v_238: G = __r_arr[1]; let __v_239: G = __r_arr[2]; @@ -22677,15 +22916,15 @@ fn aiur_fn_237( let __v_253: G = G::from_u64(0); let __v_254: G = G::from_u64(1); let __v_255: G = G::from_u64(1); - let __v_256: G = { let __values: [G; 10] = [__v_254, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_257: G = { let __values: [G; 10] = [__v_253, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_256]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_258: G = { let __values: [G; 10] = [__v_252, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_259: G = { let __values: [G; 10] = [__v_251, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_258]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_260: G = { let __values: [G; 10] = [__v_250, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_259]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_261: G = { let __values: [G; 10] = [__v_249, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_260]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_262: G = { let __values: [G; 10] = [__v_248, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_261]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_263: G = { let __values: [G; 10] = [__v_247, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_262]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_246]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_256: G = { let __values: [G; 10] = [__v_254, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255, __v_255]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_257: G = { let __values: [G; 10] = [__v_253, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_256]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_258: G = { let __values: [G; 10] = [__v_252, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_257]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_259: G = { let __values: [G; 10] = [__v_251, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_258]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_260: G = { let __values: [G; 10] = [__v_250, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_259]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_261: G = { let __values: [G; 10] = [__v_249, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_260]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_262: G = { let __values: [G; 10] = [__v_248, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_261]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_263: G = { let __values: [G; 10] = [__v_247, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_262]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_246]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_264: G = __r_arr[0]; let __v_265: G = __r_arr[1]; let __v_266: G = __r_arr[2]; @@ -22696,22 +22935,22 @@ fn aiur_fn_237( let __v_271: G = __r_arr[7]; let __v_272: G = __r_arr[8]; let __v_273: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_273, __v_264]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_273, __v_264]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_274: G = __r_arr[0]; let __v_275: G = __r_arr[1]; let __v_276: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_276]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_276]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[94].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i)?; } record.function_queries[94].output_at(__i).to_array::() }, _ => aiur_fn_94(__key, record, io_buffer, __cu)? } }; let __v_277: G = __r_arr[0]; let __v_278: G = __r_arr[1]; let __v_279: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_279, __v_264]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_279, __v_264]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_280: G = __r_arr[0]; let __v_281: G = __r_arr[1]; let __v_282: G = G::from_u64(0); - let __v_283: G = { let __values: [G; 10] = [__v_282, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_275]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_263, __v_283]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_283: G = { let __values: [G; 10] = [__v_282, __v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272, __v_275]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_263, __v_283]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_284: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_281.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_281.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_285: G = __loaded[0]; let __v_286: G = __loaded[1]; let __v_287: G = __loaded[2]; @@ -22727,7 +22966,7 @@ fn aiur_fn_237( return Err(ExecError::AssertEqMismatch { lhs: __v_287.as_canonical_u64(), rhs: __v_289.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_237] = [__v_177, __v_187, __v_197, __v_207, __v_217, __v_227, __v_237, __v_284, __v_274, __v_277, __v_278, __v_280]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[237].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22736,78 +22975,79 @@ const INPUT_SIZE_238: usize = 13; const IN_238: usize = 13; const OUT_238: usize = 1; fn aiur_fn_238( - inp: [G; IN_238], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(238); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; let __v_13: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_14: G = __io_pair.0; let __v_15: G = __io_pair.1; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_33, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_39, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_39, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_47]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_47]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -22817,17 +23057,17 @@ fn aiur_fn_238( let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; let __v_56: G = __r_arr[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[60].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i)?; } record.function_queries[60].output_at(__i).to_array::() }, _ => aiur_fn_60(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(2); @@ -22835,17 +23075,17 @@ fn aiur_fn_238( let __v_67: G = __io_pair.0; let __v_68: G = __io_pair.1; let __v_69: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_69, __v_67, __v_68]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_69, __v_67, __v_68]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_72, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_72, __v_71]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_0.as_canonical_u64() { _ => { @@ -22853,9 +23093,9 @@ fn aiur_fn_238( _ => { match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; match __v_20.as_canonical_u64() { _ => { @@ -22863,7 +23103,7 @@ fn aiur_fn_238( 0u64 => { let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 3] = [__v_78, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 3] = [__v_78, __v_79, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_80]; }, 1u64 => { @@ -22875,15 +23115,15 @@ fn aiur_fn_238( } }; let __v_78: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_30, __v_70]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_30, __v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_20, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_20, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_78, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_78, __v_80]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_18, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_18, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_82]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(109); @@ -22913,24 +23153,24 @@ fn aiur_fn_238( let __v_109: G = G::from_u64(118); let __v_110: G = G::from_u64(0); let __v_111: G = G::from_u64(48); - let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_113: G = { let __values: [G; 3] = [__v_108, __v_109, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_114: G = { let __values: [G; 3] = [__v_106, __v_107, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_115: G = { let __values: [G; 3] = [__v_104, __v_105, __v_114]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_116: G = { let __values: [G; 3] = [__v_102, __v_103, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_117: G = { let __values: [G; 3] = [__v_100, __v_101, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_118: G = { let __values: [G; 3] = [__v_98, __v_99, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_119: G = { let __values: [G; 3] = [__v_96, __v_97, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_120: G = { let __values: [G; 3] = [__v_94, __v_95, __v_119]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_121: G = { let __values: [G; 3] = [__v_92, __v_93, __v_120]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_122: G = { let __values: [G; 3] = [__v_90, __v_91, __v_121]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_123: G = { let __values: [G; 3] = [__v_88, __v_89, __v_122]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_124: G = { let __values: [G; 3] = [__v_86, __v_87, __v_123]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_125: G = { let __values: [G; 3] = [__v_84, __v_85, __v_124]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_113: G = { let __values: [G; 3] = [__v_108, __v_109, __v_112]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_114: G = { let __values: [G; 3] = [__v_106, __v_107, __v_113]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_115: G = { let __values: [G; 3] = [__v_104, __v_105, __v_114]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_116: G = { let __values: [G; 3] = [__v_102, __v_103, __v_115]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_117: G = { let __values: [G; 3] = [__v_100, __v_101, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_118: G = { let __values: [G; 3] = [__v_98, __v_99, __v_117]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_119: G = { let __values: [G; 3] = [__v_96, __v_97, __v_118]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_120: G = { let __values: [G; 3] = [__v_94, __v_95, __v_119]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_121: G = { let __values: [G; 3] = [__v_92, __v_93, __v_120]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_122: G = { let __values: [G; 3] = [__v_90, __v_91, __v_121]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_123: G = { let __values: [G; 3] = [__v_88, __v_89, __v_122]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_124: G = { let __values: [G; 3] = [__v_86, __v_87, __v_123]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_125: G = { let __values: [G; 3] = [__v_84, __v_85, __v_124]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_126: G = G::from_u64(1); let __v_127: G = G::from_u64(1); - let __v_128: G = { let __values: [G; 3] = [__v_126, __v_127, __v_127]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_125, __v_128]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_128: G = { let __values: [G; 3] = [__v_126, __v_127, __v_127]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_125, __v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -22951,17 +23191,17 @@ fn aiur_fn_238( let __v_146: G = __r_arr[17]; let __v_147: G = G::from_u64(1); let __v_148: G = G::from_u64(1); - let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_149]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_149]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_150: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_150]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_150]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_145, __v_151]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_145, __v_151]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_152: G = __r_arr[0]; let __v_153: G = G::from_u64(1); let __v_154: G = G::from_u64(1); - let __v_155: G = { let __values: [G; 3] = [__v_153, __v_154, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_152, __v_155]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_155: G = { let __values: [G; 3] = [__v_153, __v_154, __v_154]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_152, __v_155]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: G = __r_arr[2]; @@ -22982,26 +23222,26 @@ fn aiur_fn_238( let __v_173: G = __r_arr[17]; let __v_174: G = G::from_u64(1); let __v_175: G = G::from_u64(1); - let __v_176: G = { let __values: [G; 3] = [__v_174, __v_175, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_176]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_176: G = { let __values: [G; 3] = [__v_174, __v_175, __v_175]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_176]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_177: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_177]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_177]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_178: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_172, __v_178]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_172, __v_178]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_179: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_179, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_179, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_180: G = __r_arr[0]; let __v_181: G = G::from_u64(1); let __v_182: G = G::from_u64(1); - let __v_183: G = { let __values: [G; 3] = [__v_181, __v_182, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26, __v_183]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_183: G = { let __values: [G; 3] = [__v_181, __v_182, __v_182]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26, __v_183]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_184: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_180, __v_184]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_180, __v_184]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_185: G = __r_arr[0]; let __v_186: G = G::from_u64(1); let __v_187: G = G::from_u64(1); - let __v_188: G = { let __values: [G; 3] = [__v_186, __v_187, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_185, __v_188]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_188: G = { let __values: [G; 3] = [__v_186, __v_187, __v_187]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_185, __v_188]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; @@ -23020,12 +23260,12 @@ fn aiur_fn_238( let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_205, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_205, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_207: G = __r_arr[0]; let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(1); - let __v_210: G = { let __values: [G; 3] = [__v_208, __v_209, __v_209]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_207, __v_210]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_210: G = { let __values: [G; 3] = [__v_208, __v_209, __v_209]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_207, __v_210]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_211: G = __r_arr[0]; let __v_212: G = __r_arr[1]; let __v_213: G = __r_arr[2]; @@ -23214,27 +23454,27 @@ fn aiur_fn_238( let __v_396: G = (__v_219 + __v_395); let __v_397: G = G::from_u64(0); let __v_398: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_397, __v_398, __v_73, __v_249, __v_270, __v_291, __v_312]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_397, __v_398, __v_73, __v_249, __v_270, __v_291, __v_312]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_399: G = __r_arr[0]; let __v_400: G = __r_arr[1]; let __v_401: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_76, __v_77, __v_30, __v_26, __v_62, __v_64, __v_59, __v_60, __v_57, __v_401, __v_399, __v_400, __v_249, __v_270, __v_291, __v_312, __v_333, __v_354, __v_375, __v_396]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_76, __v_77, __v_30, __v_26, __v_62, __v_64, __v_59, __v_60, __v_57, __v_401, __v_399, __v_400, __v_249, __v_270, __v_291, __v_312, __v_333, __v_354, __v_375, __v_396]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_402: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_76]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_403: G = __r_arr[0]; match __v_34.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_404: G = __r_arr[0]; let __v_405: G = G::from_u64(1); let __v_406: G = G::from_u64(1); - let __v_407: G = { let __values: [G; 3] = [__v_405, __v_406, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_407: G = { let __values: [G; 3] = [__v_405, __v_406, __v_406]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_407]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_407]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_407]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_408: G = __r_arr[0]; break '__mc_1 [__v_408]; }, @@ -23244,18 +23484,18 @@ fn aiur_fn_238( } }; let __v_408: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_408]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_408]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_409: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_64, __v_409]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_64, __v_409]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_410: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_62, __v_410]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_62, __v_410]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_411: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_227, __v_411]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_227, __v_411]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_412: G = __r_arr[0]; let __v_413: G = G::from_u64(1); let __v_414: G = G::from_u64(1); - let __v_415: G = { let __values: [G; 3] = [__v_413, __v_414, __v_414]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_412, __v_415]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_415: G = { let __values: [G; 3] = [__v_413, __v_414, __v_414]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_412, __v_415]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_416: G = __r_arr[0]; let __v_417: G = __r_arr[1]; let __v_418: G = __r_arr[2]; @@ -23316,34 +23556,34 @@ fn aiur_fn_238( let __v_473: G = (__v_458 + __v_472); let __v_474: G = (__v_456 + __v_473); let __v_475: G = (__v_424 + __v_474); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_432, __v_34, __v_36, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_432, __v_34, __v_36, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_476: G = __r_arr[0]; let __v_477: G = __r_arr[1]; let __v_478: G = G::from_u64(1); let __v_479: G = G::from_u64(1); - let __v_480: G = { let __values: [G; 3] = [__v_478, __v_479, __v_479]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_46, __v_480]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_480: G = { let __values: [G; 3] = [__v_478, __v_479, __v_479]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_46, __v_480]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_481: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_477, __v_481]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_477, __v_481]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_482: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_482, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_482, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_483: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_483, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_483, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_484: G = __r_arr[0]; let __v_485: G = __r_arr[1]; let __v_486: G = (__v_404 + __v_0); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_484, __v_485, __v_4, __v_486]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_484, __v_485, __v_4, __v_486]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_487: G = __r_arr[0]; let __v_488: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_40, __v_44, __v_488, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_40, __v_44, __v_488, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_489: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_484, __v_485, __v_489, __v_454, __v_475, __v_62, __v_64, __v_57, __v_59, __v_60, __v_20, __v_22, __v_24, __v_78, __v_77, __v_30, __v_375, __v_396, __v_403, __v_0, __v_486, __v_476, __v_34, __v_46, __v_404]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_484, __v_485, __v_489, __v_454, __v_475, __v_62, __v_64, __v_57, __v_59, __v_60, __v_20, __v_22, __v_24, __v_78, __v_77, __v_30, __v_375, __v_396, __v_403, __v_0, __v_486, __v_476, __v_34, __v_46, __v_404]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_490: G = __r_arr[0]; let __v_491: G = (__v_14 + __v_15); if (__v_65 != __v_491) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_491.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_492: G = __loaded[0]; let __v_493: G = __loaded[1]; let __v_494: G = __loaded[2]; @@ -23363,22 +23603,22 @@ fn aiur_fn_238( if (__v_497 != __v_498) { return Err(ExecError::AssertEqMismatch { lhs: __v_497.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_499: G = __r_arr[0]; if (__v_499 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_499.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_64]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_64]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_500: G = __r_arr[0]; if (__v_500 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_500.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_57]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_501: G = __r_arr[0]; if (__v_501 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_501.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_502: G = __r_arr[0]; let __v_503: G = G::from_u64(1); if (__v_502 != __v_503) { @@ -23401,15 +23641,15 @@ fn aiur_fn_238( if (__v_3 != __v_508) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_508.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_509: G = __r_arr[0]; let __v_510: G = G::from_u64(1); if (__v_509 != __v_510) { return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_510.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_511: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_512: G = __r_arr[0]; let __v_513: G = (__v_511 - __v_512); let __v_514: G = G::from_bool((__v_513 == G::ZERO)); @@ -23417,9 +23657,9 @@ fn aiur_fn_238( if (__v_514 != __v_515) { return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_76]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_516: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_517: G = __r_arr[0]; let __v_518: G = (__v_516 - __v_517); let __v_519: G = G::from_bool((__v_518 == G::ZERO)); @@ -23427,7 +23667,7 @@ fn aiur_fn_238( if (__v_519 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_519.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_521: G = __r_arr[0]; let __v_522: G = (__v_521 - __v_404); let __v_523: G = G::from_bool((__v_522 == G::ZERO)); @@ -23435,16 +23675,16 @@ fn aiur_fn_238( if (__v_523 != __v_524) { return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_524.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_525: G = __r_arr[0]; let __v_526: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_59, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_527: G = __r_arr[0]; let __v_528: G = (__v_526 + __v_527); if (__v_525 != __v_528) { return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_528.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_529: G = __r_arr[0]; let __v_530: G = (__v_529 - __v_404); let __v_531: G = G::from_bool((__v_530 == G::ZERO)); @@ -23452,33 +23692,33 @@ fn aiur_fn_238( if (__v_531 != __v_532) { return Err(ExecError::AssertEqMismatch { lhs: __v_531.as_canonical_u64(), rhs: __v_532.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_533: G = __r_arr[0]; let __v_534: G = G::from_u64(1); if (__v_533 != __v_534) { return Err(ExecError::AssertEqMismatch { lhs: __v_533.as_canonical_u64(), rhs: __v_534.as_canonical_u64(), msg: None }); } let __v_535: G = G::from_u64(33); - let __v_536: G = { let __a_val = __v_486.as_canonical_u64(); let __b_val = __v_535.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_536: G = { let __a_val = __v_486.as_canonical_u64(); let __b_val = __v_535.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_537: G = G::from_u64(1); if (__v_536 != __v_537) { return Err(ExecError::AssertEqMismatch { lhs: __v_536.as_canonical_u64(), rhs: __v_537.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_40, __v_487, __v_20, __v_22, __v_24, __v_78, __v_59, __v_60, __v_77, __v_30, __v_403, __v_0, __v_486]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_40, __v_487, __v_20, __v_22, __v_24, __v_78, __v_59, __v_60, __v_77, __v_30, __v_403, __v_0, __v_486]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_538: G = __r_arr[0]; let __v_539: G = G::from_u64(1); if (__v_538 != __v_539) { return Err(ExecError::AssertEqMismatch { lhs: __v_538.as_canonical_u64(), rhs: __v_539.as_canonical_u64(), msg: None }); } let __v_540: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_44, __v_34, __v_490, __v_487, __v_540, __v_486]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_44, __v_34, __v_490, __v_487, __v_540, __v_486]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_541: G = __r_arr[0]; let __v_542: G = G::from_u64(1); if (__v_541 != __v_542) { return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_542.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_238] = [__v_73]; - record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23499,41 +23739,42 @@ const INPUT_SIZE_239: usize = 28; const IN_239: usize = 28; const OUT_239: usize = 8; fn aiur_fn_239( - inp: [G; IN_239], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } }; + record.checkpoint(239); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[237].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i)?; } record.function_queries[237].output_at(__i).to_array::() }, _ => aiur_fn_237(__key, 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]; @@ -23546,12 +23787,12 @@ fn aiur_fn_239( let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; let __v_39: G = __r_arr[11]; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[238].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i)?; } record.function_queries[238].output_at(__i).to_array::() }, _ => aiur_fn_238(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[236].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i)?; } record.function_queries[236].output_at(__i).to_array::() }, _ => aiur_fn_236(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); if (__v_43 != __v_44) { @@ -23559,20 +23800,20 @@ fn aiur_fn_239( } match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(10); if (__v_45 != __v_46) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64(), msg: Some("aggr: IxVM child must expose a 10-word verify_claim claim".to_string()) }); } let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; if (__v_48 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: IxVM child has the wrong entrypoint".to_string()) }); } let __v_49: G = G::from_u64(2); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_41, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_41, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23582,12 +23823,12 @@ fn aiur_fn_239( let __v_56: G = __r_arr[6]; let __v_57: G = __r_arr[7]; let __ret: [G; OUT_239] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; - record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_45: G = G::from_u64(2); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_41, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_41, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -23596,21 +23837,21 @@ fn aiur_fn_239( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(18); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64(), msg: Some("aggr: recursive child must expose an 18-word ix_aggr claim".to_string()) }); } let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; if (__v_57 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: recursive child has the wrong entrypoint".to_string()) }); } let __v_58: G = G::from_u64(10); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_41, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_41, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23620,7 +23861,7 @@ fn aiur_fn_239( let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; let __ret: [G; OUT_239] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; - record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23631,49 +23872,50 @@ const INPUT_SIZE_240: usize = 35; const IN_240: usize = 35; const OUT_240: usize = 0; fn aiur_fn_240( - inp: [G; IN_240], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; + record.checkpoint(240); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -23682,9 +23924,9 @@ fn aiur_fn_240( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_240] = []; - record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[240].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -23693,50 +23935,51 @@ const INPUT_SIZE_241: usize = 36; const IN_241: usize = 36; const OUT_241: usize = 0; fn aiur_fn_241( - inp: [G; IN_241], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; + record.checkpoint(241); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -23746,7 +23989,7 @@ fn aiur_fn_241( let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -23755,15 +23998,15 @@ fn aiur_fn_241( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_54]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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_232] = { let __args: [G; IN_232] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_58]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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]; @@ -23773,7 +24016,7 @@ fn aiur_fn_241( let __v_64: G = __io_pair.0; let __v_65: G = __io_pair.1; let __v_66: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_66, __v_64, __v_65]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_66, __v_64, __v_65]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(103); let __v_69: G = G::from_u64(230); @@ -23809,7 +24052,7 @@ fn aiur_fn_241( let __v_99: G = G::from_u64(91); let __v_100: G = G::from_u64(1); let __v_101: G = G::from_u64(1); - let __v_102: G = { let __values: [G; 3] = [__v_100, __v_101, __v_101]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_102: G = { let __values: [G; 3] = [__v_100, __v_101, __v_101]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_103: G = G::from_u64(0); let __v_104: G = G::from_u64(0); let __v_105: G = G::from_u64(0); @@ -23820,14 +24063,14 @@ fn aiur_fn_241( let __v_110: G = G::from_u64(0); let __v_111: G = G::from_u64(0); let __v_112: G = G::from_u64(0); - let __v_113: G = { let __values: [G; 8] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_114: G = { let __values: [G; 32] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_113: G = { let __values: [G; 8] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_114: G = { let __values: [G; 32] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_115: G = G::from_u64(1); let __v_116: G = G::from_u64(1); - let __v_117: G = { let __values: [G; 34] = [__v_115, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_67, __v_102, __v_103, __v_104, __v_113, __v_114, __v_117]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_117: G = { let __values: [G; 34] = [__v_115, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_67, __v_102, __v_103, __v_104, __v_113, __v_114, __v_117]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -23860,24 +24103,24 @@ fn aiur_fn_241( let __v_148: G = __r_arr[29]; let __v_149: G = __r_arr[30]; let __v_150: G = __r_arr[31]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_154: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_59]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_56, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_56, __v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_156: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_151]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_151]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_158: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_152, __v_153]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_152, __v_153]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_159: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_154, __v_155, __v_158]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_156, __v_157, __v_158, __v_159]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_154, __v_155, __v_158]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_156, __v_157, __v_158, __v_159]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, record, io_buffer, __cu)? } }; let __v_160: G = G::from_u64(256); let __v_161: G = (__v_160 * __v_120); let __v_162: G = G::from_u64(65536); @@ -23975,7 +24218,7 @@ fn aiur_fn_241( return Err(ExecError::AssertEqMismatch { lhs: __v_231.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr: output claim digest mismatch".to_string()) }); } let __ret: [G; OUT_241] = []; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[241].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -23984,50 +24227,51 @@ const INPUT_SIZE_242: usize = 36; const IN_242: usize = 36; const OUT_242: usize = 0; fn aiur_fn_242( - inp: [G; IN_242], + inp: QueryKey, 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]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; + record.checkpoint(242); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0, __v_36, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -24037,7 +24281,7 @@ fn aiur_fn_242( let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; let __v_45: G = G::from_u64(1); - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_1, __v_45, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -24046,15 +24290,15 @@ fn aiur_fn_242( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_54]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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_232] = { let __args: [G; IN_232] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_58]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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]; @@ -24064,7 +24308,7 @@ fn aiur_fn_242( let __v_64: G = __io_pair.0; let __v_65: G = __io_pair.1; let __v_66: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_66, __v_64, __v_65]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_66, __v_64, __v_65]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(103); let __v_69: G = G::from_u64(230); @@ -24100,7 +24344,7 @@ fn aiur_fn_242( let __v_99: G = G::from_u64(91); let __v_100: G = G::from_u64(1); let __v_101: G = G::from_u64(1); - let __v_102: G = { let __values: [G; 3] = [__v_100, __v_101, __v_101]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_102: G = { let __values: [G; 3] = [__v_100, __v_101, __v_101]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_103: G = G::from_u64(0); let __v_104: G = G::from_u64(0); let __v_105: G = G::from_u64(0); @@ -24111,14 +24355,14 @@ fn aiur_fn_242( let __v_110: G = G::from_u64(0); let __v_111: G = G::from_u64(0); let __v_112: G = G::from_u64(0); - let __v_113: G = { let __values: [G; 8] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_114: G = { let __values: [G; 32] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_113: G = { let __values: [G; 8] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_114: G = { let __values: [G; 32] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_115: G = G::from_u64(1); let __v_116: G = G::from_u64(1); - let __v_117: G = { let __values: [G; 34] = [__v_115, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_67, __v_102, __v_103, __v_104, __v_113, __v_114, __v_117]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_117: G = { let __values: [G; 34] = [__v_115, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_67, __v_102, __v_103, __v_104, __v_113, __v_114, __v_117]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -24151,19 +24395,19 @@ fn aiur_fn_242( let __v_148: G = __r_arr[29]; let __v_149: G = __r_arr[30]; let __v_150: G = __r_arr[31]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_55, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_55, __v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_154: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_56, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_56, __v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_156: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_152, __v_153]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_152, __v_153]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_155, __v_156, __v_151, __v_157]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_155, __v_156, __v_151, __v_157]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __v_158: G = G::from_u64(256); let __v_159: G = (__v_158 * __v_120); let __v_160: G = G::from_u64(65536); @@ -24260,14 +24504,14 @@ fn aiur_fn_242( if (__v_229 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_229.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("aggr structural: output claim digest mismatch".to_string()) }); } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_151, __v_154]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_151, __v_154]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_230: G = __r_arr[0]; let __v_231: G = G::from_u64(1); if (__v_230 != __v_231) { return Err(ExecError::AssertEqMismatch { lhs: __v_230.as_canonical_u64(), rhs: __v_231.as_canonical_u64(), msg: Some("aggr structural: output subject root is not nodeHash(left, right)".to_string()) }); } let __ret: [G; OUT_242] = []; - record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[242].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -24276,35 +24520,36 @@ const INPUT_SIZE_243: usize = 16; const IN_243: usize = 16; const OUT_243: usize = 0; fn aiur_fn_243( - inp: [G; IN_243], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(243); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(3); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -24340,7 +24585,7 @@ fn aiur_fn_243( let __v_53: G = G::from_u64(91); let __v_54: G = G::from_u64(1); let __v_55: G = G::from_u64(1); - let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -24351,14 +24596,14 @@ fn aiur_fn_243( let __v_64: G = G::from_u64(0); let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -24391,61 +24636,61 @@ fn aiur_fn_243( 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_207] = { let __args: [G; IN_207] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_122]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_122]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_133: G = __r_arr[0]; let __v_134: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_135: G = __r_arr[0]; let __v_136: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, 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]; @@ -24454,7 +24699,7 @@ fn aiur_fn_243( let __v_146: G = __r_arr[5]; let __v_147: G = __r_arr[6]; let __v_148: G = __r_arr[7]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_123]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_123]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, record, io_buffer, __cu)? } }; let __v_149: G = __r_arr[0]; let __v_150: G = __r_arr[1]; let __v_151: G = __r_arr[2]; @@ -24463,9 +24708,9 @@ fn aiur_fn_243( let __v_154: G = __r_arr[5]; let __v_155: G = __r_arr[6]; let __v_156: G = __r_arr[7]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_158: G = __r_arr[0]; let __v_159: G = G::from_u64(6); let __v_160: G = G::from_u64(0); @@ -24473,9 +24718,9 @@ fn aiur_fn_243( let __v_161: G = __io_pair.0; let __v_162: G = __io_pair.1; let __v_163: G = G::from_u64(6); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_163, __v_161, __v_162]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_163, __v_161, __v_162]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_164: G = __r_arr[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_164]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; let __v_166: G = __r_arr[1]; let __v_167: G = G::from_u64(80); @@ -24578,7 +24823,7 @@ fn aiur_fn_243( if (__v_239 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_239.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("aggr: allowed blob digest mismatch".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_140.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_140.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_240: G = __loaded[0]; let __v_241: G = __loaded[1]; let __v_242: G = __loaded[2]; @@ -24597,7 +24842,7 @@ fn aiur_fn_243( if (__v_162 != __v_245) { return Err(ExecError::AssertEqMismatch { lhs: __v_162.as_canonical_u64(), rhs: __v_245.as_canonical_u64(), msg: Some("aggr: shape hint must be exactly one byte".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_166.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_166.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_246: G = __loaded[0]; let __v_247: G = __loaded[1]; let __v_248: G = __loaded[2]; @@ -24615,80 +24860,80 @@ fn aiur_fn_243( match __v_165.as_canonical_u64() { 0u64 => { let __v_251: G = G::from_u64(0); - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[240].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i)?; } record.function_queries[240].output_at(__i).to_array::() }, _ => aiur_fn_240(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_251: G = G::from_u64(1); - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_251, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[240].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i)?; } record.function_queries[240].output_at(__i).to_array::() }, _ => aiur_fn_240(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_251: G = G::from_u64(0); let __v_252: G = G::from_u64(0); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[241].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i)?; } record.function_queries[241].output_at(__i).to_array::() }, _ => aiur_fn_241(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_251: G = G::from_u64(0); let __v_252: G = G::from_u64(1); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[241].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i)?; } record.function_queries[241].output_at(__i).to_array::() }, _ => aiur_fn_241(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_251: G = G::from_u64(1); let __v_252: G = G::from_u64(0); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[241].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i)?; } record.function_queries[241].output_at(__i).to_array::() }, _ => aiur_fn_241(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_251: G = G::from_u64(1); let __v_252: G = G::from_u64(1); - let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[241].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i)?; } record.function_queries[241].output_at(__i).to_array::() }, _ => aiur_fn_241(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_251: G = G::from_u64(0); let __v_252: G = G::from_u64(0); - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[242].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i)?; } record.function_queries[242].output_at(__i).to_array::() }, _ => aiur_fn_242(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_251: G = G::from_u64(0); let __v_252: G = G::from_u64(1); - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[242].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i)?; } record.function_queries[242].output_at(__i).to_array::() }, _ => aiur_fn_242(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_251: G = G::from_u64(1); let __v_252: G = G::from_u64(0); - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[242].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i)?; } record.function_queries[242].output_at(__i).to_array::() }, _ => aiur_fn_242(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { let __v_251: G = G::from_u64(1); let __v_252: G = G::from_u64(1); - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_251, __v_252, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[242].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i)?; } record.function_queries[242].output_at(__i).to_array::() }, _ => aiur_fn_242(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_243] = []; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24702,24 +24947,25 @@ const INPUT_SIZE_244: usize = 2; const IN_244: usize = 2; const OUT_244: usize = 1; fn aiur_fn_244( - inp: [G; IN_244], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + record.checkpoint(244); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_244] = [__v_4]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[244].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24733,14 +24979,15 @@ const INPUT_SIZE_245: usize = 1; const IN_245: usize = 1; const OUT_245: usize = 1; fn aiur_fn_245( - inp: [G; IN_245], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(245); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -24748,16 +24995,16 @@ fn aiur_fn_245( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_4]; - record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, 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_245] = [__v_6]; - record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24771,14 +25018,15 @@ const INPUT_SIZE_246: usize = 1; const IN_246: usize = 1; const OUT_246: usize = 1; fn aiur_fn_246( - inp: [G; IN_246], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(246); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -24787,16 +25035,16 @@ fn aiur_fn_246( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_246] = [__v_5]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, 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_246] = [__v_7]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24810,31 +25058,32 @@ const INPUT_SIZE_247: usize = 2; const IN_247: usize = 2; const OUT_247: usize = 1; fn aiur_fn_247( - inp: [G; IN_247], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(247); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_247] = [__v_1]; - record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[247].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_247] = [__v_7]; - record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[247].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24848,14 +25097,15 @@ const INPUT_SIZE_248: usize = 1; const IN_248: usize = 1; const OUT_248: usize = 1; fn aiur_fn_248( - inp: [G; IN_248], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(248); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -24866,16 +25116,16 @@ fn aiur_fn_248( 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_7]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); let __ret: [G; OUT_248] = [__v_9]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24889,14 +25139,15 @@ const INPUT_SIZE_249: usize = 1; const IN_249: usize = 1; const OUT_249: usize = 1; fn aiur_fn_249( - inp: [G; IN_249], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_249], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(249); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -24908,16 +25159,16 @@ fn aiur_fn_249( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_8]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[249].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, 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_249] = [__v_10]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[249].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24931,14 +25182,15 @@ const INPUT_SIZE_250: usize = 1; const IN_250: usize = 1; const OUT_250: usize = 1; fn aiur_fn_250( - inp: [G; IN_250], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(250); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -24953,16 +25205,16 @@ fn aiur_fn_250( 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_250] = [__v_11]; - record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[250].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, 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_250] = [__v_13]; - record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[250].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24976,17 +25228,18 @@ const INPUT_SIZE_251: usize = 2; const IN_251: usize = 2; const OUT_251: usize = 4; fn aiur_fn_251( - inp: [G; IN_251], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; + record.checkpoint(251); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[260].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i)?; } record.function_queries[260].output_at(__i).to_array::() }, _ => aiur_fn_260(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -24996,7 +25249,7 @@ fn aiur_fn_251( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_251] = [__v_4, __v_5, __v_6, __v_7]; - record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[251].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25010,14 +25263,15 @@ const INPUT_SIZE_252: usize = 1; const IN_252: usize = 1; const OUT_252: usize = 1; fn aiur_fn_252( - inp: [G; IN_252], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(252); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -25025,13 +25279,13 @@ fn aiur_fn_252( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_252] = [__v_4]; - record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[252].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_252] = [__v_4]; - record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[252].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25045,17 +25299,18 @@ const INPUT_SIZE_253: usize = 2; const IN_253: usize = 2; const OUT_253: usize = 2; fn aiur_fn_253( - inp: [G; IN_253], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } }; + record.checkpoint(253); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[259].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i)?; } record.function_queries[259].output_at(__i).to_array::() }, _ => aiur_fn_259(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -25063,7 +25318,7 @@ fn aiur_fn_253( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_253] = [__v_4, __v_5]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[253].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25077,15 +25332,16 @@ const INPUT_SIZE_254: usize = 2; const IN_254: usize = 2; const OUT_254: usize = 1; fn aiur_fn_254( - inp: [G; IN_254], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(254); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -25099,16 +25355,16 @@ fn aiur_fn_254( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_254] = [__v_1]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_254] = [__v_14]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25122,14 +25378,15 @@ const INPUT_SIZE_255: usize = 1; const IN_255: usize = 1; const OUT_255: usize = 1; fn aiur_fn_255( - inp: [G; IN_255], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(255); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -25139,16 +25396,16 @@ fn aiur_fn_255( 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_255] = [__v_6]; - record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, 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_255] = [__v_8]; - record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25162,33 +25419,34 @@ const INPUT_SIZE_256: usize = 2; const IN_256: usize = 2; const OUT_256: usize = 1; fn aiur_fn_256( - inp: [G; IN_256], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(256); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_256] = [__v_0]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_256] = [__v_7]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25204,14 +25462,15 @@ const INPUT_SIZE_257: usize = 1; const IN_257: usize = 1; const OUT_257: usize = 1; fn aiur_fn_257( - inp: [G; IN_257], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_257], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + record.checkpoint(257); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -25224,16 +25483,16 @@ fn aiur_fn_257( 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_257] = [__v_9]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[257].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, 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_257] = [__v_11]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[257].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25247,17 +25506,18 @@ const INPUT_SIZE_258: usize = 2; const IN_258: usize = 2; const OUT_258: usize = 8; fn aiur_fn_258( - inp: [G; IN_258], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[261].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => aiur_fn_261(__args, record, io_buffer, __cu)? } }; + record.checkpoint(258); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[261].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i)?; } record.function_queries[261].output_at(__i).to_array::() }, _ => aiur_fn_261(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -25271,7 +25531,7 @@ fn aiur_fn_258( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_258] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25285,26 +25545,27 @@ const INPUT_SIZE_259: usize = 2; const IN_259: usize = 2; const OUT_259: usize = 1; fn aiur_fn_259( - inp: [G; IN_259], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(259); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_259] = [__v_0]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[259].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i)?; } record.function_queries[259].output_at(__i).to_array::() }, _ => aiur_fn_259(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -25312,7 +25573,7 @@ fn aiur_fn_259( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_259] = [__v_8]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25328,26 +25589,27 @@ const INPUT_SIZE_260: usize = 2; const IN_260: usize = 2; const OUT_260: usize = 1; fn aiur_fn_260( - inp: [G; IN_260], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(260); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_260] = [__v_0]; - record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[260].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[260].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i)?; } record.function_queries[260].output_at(__i).to_array::() }, _ => aiur_fn_260(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -25357,7 +25619,7 @@ fn aiur_fn_260( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_260] = [__v_10]; - record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[260].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25373,26 +25635,27 @@ const INPUT_SIZE_261: usize = 2; const IN_261: usize = 2; const OUT_261: usize = 1; fn aiur_fn_261( - inp: [G; IN_261], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(261); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_261] = [__v_0]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[261].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[261].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i)?; } record.function_queries[261].output_at(__i).to_array::() }, _ => aiur_fn_261(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -25406,7 +25669,7 @@ fn aiur_fn_261( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_261] = [__v_14]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25427,1312 +25690,1312 @@ pub(crate) fn execute_generated( match fun_idx as u64 { 0u64 => { let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_0(__inp, record, io_buffer, false)?; + let __out = aiur_fn_0(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 1u64 => { let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_1(__inp, record, io_buffer, false)?; + let __out = aiur_fn_1(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 2u64 => { let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_2(__inp, record, io_buffer, false)?; + let __out = aiur_fn_2(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 3u64 => { let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_3(__inp, record, io_buffer, false)?; + let __out = aiur_fn_3(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 4u64 => { let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_4(__inp, record, io_buffer, false)?; + let __out = aiur_fn_4(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 5u64 => { let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_5(__inp, record, io_buffer, false)?; + let __out = aiur_fn_5(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 6u64 => { let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_6(__inp, record, io_buffer, false)?; + let __out = aiur_fn_6(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 7u64 => { let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_7(__inp, record, io_buffer, false)?; + let __out = aiur_fn_7(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 8u64 => { let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_8(__inp, record, io_buffer, false)?; + let __out = aiur_fn_8(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 9u64 => { let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_9(__inp, record, io_buffer, false)?; + let __out = aiur_fn_9(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 10u64 => { let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_10(__inp, record, io_buffer, false)?; + let __out = aiur_fn_10(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 11u64 => { let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_11(__inp, record, io_buffer, false)?; + let __out = aiur_fn_11(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 12u64 => { let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_12(__inp, record, io_buffer, false)?; + let __out = aiur_fn_12(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 13u64 => { let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_13(__inp, record, io_buffer, false)?; + let __out = aiur_fn_13(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 14u64 => { let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_14(__inp, record, io_buffer, false)?; + let __out = aiur_fn_14(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 15u64 => { let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_15(__inp, record, io_buffer, false)?; + let __out = aiur_fn_15(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 16u64 => { let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_16(__inp, record, io_buffer, false)?; + let __out = aiur_fn_16(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 17u64 => { let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_17(__inp, record, io_buffer, false)?; + let __out = aiur_fn_17(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 18u64 => { let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_18(__inp, record, io_buffer, false)?; + let __out = aiur_fn_18(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 19u64 => { let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_19(__inp, record, io_buffer, false)?; + let __out = aiur_fn_19(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 20u64 => { let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_20(__inp, record, io_buffer, false)?; + let __out = aiur_fn_20(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 21u64 => { let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_21(__inp, record, io_buffer, false)?; + let __out = aiur_fn_21(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 22u64 => { let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_22(__inp, record, io_buffer, false)?; + let __out = aiur_fn_22(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 23u64 => { let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_23(__inp, record, io_buffer, false)?; + let __out = aiur_fn_23(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 24u64 => { let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_24(__inp, record, io_buffer, false)?; + let __out = aiur_fn_24(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 25u64 => { let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_25(__inp, record, io_buffer, false)?; + let __out = aiur_fn_25(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 26u64 => { let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_26(__inp, record, io_buffer, false)?; + let __out = aiur_fn_26(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 27u64 => { let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_27(__inp, record, io_buffer, false)?; + let __out = aiur_fn_27(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 28u64 => { let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_28(__inp, record, io_buffer, false)?; + let __out = aiur_fn_28(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 29u64 => { let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_29(__inp, record, io_buffer, false)?; + let __out = aiur_fn_29(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 30u64 => { let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_30(__inp, record, io_buffer, false)?; + let __out = aiur_fn_30(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 31u64 => { let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_31(__inp, record, io_buffer, false)?; + let __out = aiur_fn_31(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 32u64 => { let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_32(__inp, record, io_buffer, false)?; + let __out = aiur_fn_32(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 33u64 => { let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_33(__inp, record, io_buffer, false)?; + let __out = aiur_fn_33(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 34u64 => { let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_34(__inp, record, io_buffer, false)?; + let __out = aiur_fn_34(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 35u64 => { let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_35(__inp, record, io_buffer, false)?; + let __out = aiur_fn_35(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 36u64 => { let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_36(__inp, record, io_buffer, false)?; + let __out = aiur_fn_36(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 37u64 => { let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_37(__inp, record, io_buffer, false)?; + let __out = aiur_fn_37(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 38u64 => { let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_38(__inp, record, io_buffer, false)?; + let __out = aiur_fn_38(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 39u64 => { let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_39(__inp, record, io_buffer, false)?; + let __out = aiur_fn_39(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 40u64 => { let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_40(__inp, record, io_buffer, false)?; + let __out = aiur_fn_40(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 41u64 => { let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_41(__inp, record, io_buffer, false)?; + let __out = aiur_fn_41(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 42u64 => { let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_42(__inp, record, io_buffer, false)?; + let __out = aiur_fn_42(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 43u64 => { let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_43(__inp, record, io_buffer, false)?; + let __out = aiur_fn_43(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 44u64 => { let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_44(__inp, record, io_buffer, false)?; + let __out = aiur_fn_44(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 45u64 => { let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_45(__inp, record, io_buffer, false)?; + let __out = aiur_fn_45(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 46u64 => { let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_46(__inp, record, io_buffer, false)?; + let __out = aiur_fn_46(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 47u64 => { let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_47(__inp, record, io_buffer, false)?; + let __out = aiur_fn_47(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 48u64 => { let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_48(__inp, record, io_buffer, false)?; + let __out = aiur_fn_48(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 49u64 => { let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_49(__inp, record, io_buffer, false)?; + let __out = aiur_fn_49(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 50u64 => { let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_50(__inp, record, io_buffer, false)?; + let __out = aiur_fn_50(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 51u64 => { let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_51(__inp, record, io_buffer, false)?; + let __out = aiur_fn_51(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 52u64 => { let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_52(__inp, record, io_buffer, false)?; + let __out = aiur_fn_52(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 53u64 => { let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_53(__inp, record, io_buffer, false)?; + let __out = aiur_fn_53(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 54u64 => { let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_54(__inp, record, io_buffer, false)?; + let __out = aiur_fn_54(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 55u64 => { let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_55(__inp, record, io_buffer, false)?; + let __out = aiur_fn_55(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 56u64 => { let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_56(__inp, record, io_buffer, false)?; + let __out = aiur_fn_56(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 57u64 => { let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_57(__inp, record, io_buffer, false)?; + let __out = aiur_fn_57(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 58u64 => { let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_58(__inp, record, io_buffer, false)?; + let __out = aiur_fn_58(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 59u64 => { let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_59(__inp, record, io_buffer, false)?; + let __out = aiur_fn_59(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 60u64 => { let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_60(__inp, record, io_buffer, false)?; + let __out = aiur_fn_60(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 61u64 => { let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_61(__inp, record, io_buffer, false)?; + let __out = aiur_fn_61(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 62u64 => { let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_62(__inp, record, io_buffer, false)?; + let __out = aiur_fn_62(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 63u64 => { let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_63(__inp, record, io_buffer, false)?; + let __out = aiur_fn_63(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 64u64 => { let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_64(__inp, record, io_buffer, false)?; + let __out = aiur_fn_64(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 65u64 => { let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_65(__inp, record, io_buffer, false)?; + let __out = aiur_fn_65(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 66u64 => { let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_66(__inp, record, io_buffer, false)?; + let __out = aiur_fn_66(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 67u64 => { let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_67(__inp, record, io_buffer, false)?; + let __out = aiur_fn_67(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 68u64 => { let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_68(__inp, record, io_buffer, false)?; + let __out = aiur_fn_68(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 69u64 => { let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_69(__inp, record, io_buffer, false)?; + let __out = aiur_fn_69(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 70u64 => { let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_70(__inp, record, io_buffer, false)?; + let __out = aiur_fn_70(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 71u64 => { let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_71(__inp, record, io_buffer, false)?; + let __out = aiur_fn_71(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 72u64 => { let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_72(__inp, record, io_buffer, false)?; + let __out = aiur_fn_72(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 73u64 => { let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_73(__inp, record, io_buffer, false)?; + let __out = aiur_fn_73(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 74u64 => { let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_74(__inp, record, io_buffer, false)?; + let __out = aiur_fn_74(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 75u64 => { let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_75(__inp, record, io_buffer, false)?; + let __out = aiur_fn_75(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 76u64 => { let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_76(__inp, record, io_buffer, false)?; + let __out = aiur_fn_76(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 77u64 => { let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_77(__inp, record, io_buffer, false)?; + let __out = aiur_fn_77(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 78u64 => { let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_78(__inp, record, io_buffer, false)?; + let __out = aiur_fn_78(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 79u64 => { let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_79(__inp, record, io_buffer, false)?; + let __out = aiur_fn_79(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 80u64 => { let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_80(__inp, record, io_buffer, false)?; + let __out = aiur_fn_80(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 81u64 => { let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_81(__inp, record, io_buffer, false)?; + let __out = aiur_fn_81(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 82u64 => { let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_82(__inp, record, io_buffer, false)?; + let __out = aiur_fn_82(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 83u64 => { let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_83(__inp, record, io_buffer, false)?; + let __out = aiur_fn_83(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 84u64 => { let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_84(__inp, record, io_buffer, false)?; + let __out = aiur_fn_84(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 85u64 => { let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_85(__inp, record, io_buffer, false)?; + let __out = aiur_fn_85(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 86u64 => { let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_86(__inp, record, io_buffer, false)?; + let __out = aiur_fn_86(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 87u64 => { let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_87(__inp, record, io_buffer, false)?; + let __out = aiur_fn_87(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 88u64 => { let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_88(__inp, record, io_buffer, false)?; + let __out = aiur_fn_88(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 89u64 => { let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_89(__inp, record, io_buffer, false)?; + let __out = aiur_fn_89(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 90u64 => { let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_90(__inp, record, io_buffer, false)?; + let __out = aiur_fn_90(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 91u64 => { let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_91(__inp, record, io_buffer, false)?; + let __out = aiur_fn_91(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 92u64 => { let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_92(__inp, record, io_buffer, false)?; + let __out = aiur_fn_92(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 93u64 => { let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_93(__inp, record, io_buffer, false)?; + let __out = aiur_fn_93(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 94u64 => { let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_94(__inp, record, io_buffer, false)?; + let __out = aiur_fn_94(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 95u64 => { let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_95(__inp, record, io_buffer, false)?; + let __out = aiur_fn_95(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 96u64 => { let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_96(__inp, record, io_buffer, false)?; + let __out = aiur_fn_96(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 97u64 => { let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_97(__inp, record, io_buffer, false)?; + let __out = aiur_fn_97(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 98u64 => { let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_98(__inp, record, io_buffer, false)?; + let __out = aiur_fn_98(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 99u64 => { let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_99(__inp, record, io_buffer, false)?; + let __out = aiur_fn_99(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 100u64 => { let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_100(__inp, record, io_buffer, false)?; + let __out = aiur_fn_100(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 101u64 => { let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_101(__inp, record, io_buffer, false)?; + let __out = aiur_fn_101(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 102u64 => { let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_102(__inp, record, io_buffer, false)?; + let __out = aiur_fn_102(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 103u64 => { let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_103(__inp, record, io_buffer, false)?; + let __out = aiur_fn_103(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 104u64 => { let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_104(__inp, record, io_buffer, false)?; + let __out = aiur_fn_104(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 105u64 => { let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_105(__inp, record, io_buffer, false)?; + let __out = aiur_fn_105(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 106u64 => { let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_106(__inp, record, io_buffer, false)?; + let __out = aiur_fn_106(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 107u64 => { let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_107(__inp, record, io_buffer, false)?; + let __out = aiur_fn_107(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 108u64 => { let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_108(__inp, record, io_buffer, false)?; + let __out = aiur_fn_108(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 109u64 => { let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_109(__inp, record, io_buffer, false)?; + let __out = aiur_fn_109(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 110u64 => { let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_110(__inp, record, io_buffer, false)?; + let __out = aiur_fn_110(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 111u64 => { let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_111(__inp, record, io_buffer, false)?; + let __out = aiur_fn_111(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 112u64 => { let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_112(__inp, record, io_buffer, false)?; + let __out = aiur_fn_112(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 113u64 => { let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_113(__inp, record, io_buffer, false)?; + let __out = aiur_fn_113(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 114u64 => { let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_114(__inp, record, io_buffer, false)?; + let __out = aiur_fn_114(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 115u64 => { let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_115(__inp, record, io_buffer, false)?; + let __out = aiur_fn_115(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 116u64 => { let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_116(__inp, record, io_buffer, false)?; + let __out = aiur_fn_116(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 117u64 => { let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_117(__inp, record, io_buffer, false)?; + let __out = aiur_fn_117(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 118u64 => { let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_118(__inp, record, io_buffer, false)?; + let __out = aiur_fn_118(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 119u64 => { let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_119(__inp, record, io_buffer, false)?; + let __out = aiur_fn_119(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 120u64 => { let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_120(__inp, record, io_buffer, false)?; + let __out = aiur_fn_120(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 121u64 => { let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_121(__inp, record, io_buffer, false)?; + let __out = aiur_fn_121(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 122u64 => { let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_122(__inp, record, io_buffer, false)?; + let __out = aiur_fn_122(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 123u64 => { let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_123(__inp, record, io_buffer, false)?; + let __out = aiur_fn_123(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 124u64 => { let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_124(__inp, record, io_buffer, false)?; + let __out = aiur_fn_124(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 125u64 => { let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_125(__inp, record, io_buffer, false)?; + let __out = aiur_fn_125(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 126u64 => { let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_126(__inp, record, io_buffer, false)?; + let __out = aiur_fn_126(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 127u64 => { let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_127(__inp, record, io_buffer, false)?; + let __out = aiur_fn_127(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 128u64 => { let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_128(__inp, record, io_buffer, false)?; + let __out = aiur_fn_128(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 129u64 => { let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_129(__inp, record, io_buffer, false)?; + let __out = aiur_fn_129(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 130u64 => { let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_130(__inp, record, io_buffer, false)?; + let __out = aiur_fn_130(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 131u64 => { let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_131(__inp, record, io_buffer, false)?; + let __out = aiur_fn_131(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 132u64 => { let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_132(__inp, record, io_buffer, false)?; + let __out = aiur_fn_132(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 133u64 => { let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_133(__inp, record, io_buffer, false)?; + let __out = aiur_fn_133(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 134u64 => { let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_134(__inp, record, io_buffer, false)?; + let __out = aiur_fn_134(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 135u64 => { let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_135(__inp, record, io_buffer, false)?; + let __out = aiur_fn_135(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 136u64 => { let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_136(__inp, record, io_buffer, false)?; + let __out = aiur_fn_136(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 137u64 => { let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_137(__inp, record, io_buffer, false)?; + let __out = aiur_fn_137(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 138u64 => { let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_138(__inp, record, io_buffer, false)?; + let __out = aiur_fn_138(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 139u64 => { let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_139(__inp, record, io_buffer, false)?; + let __out = aiur_fn_139(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 140u64 => { let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_140(__inp, record, io_buffer, false)?; + let __out = aiur_fn_140(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 141u64 => { let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_141(__inp, record, io_buffer, false)?; + let __out = aiur_fn_141(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 142u64 => { let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_142(__inp, record, io_buffer, false)?; + let __out = aiur_fn_142(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 143u64 => { let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_143(__inp, record, io_buffer, false)?; + let __out = aiur_fn_143(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 144u64 => { let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_144(__inp, record, io_buffer, false)?; + let __out = aiur_fn_144(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 145u64 => { let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_145(__inp, record, io_buffer, false)?; + let __out = aiur_fn_145(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 146u64 => { let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_146(__inp, record, io_buffer, false)?; + let __out = aiur_fn_146(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 147u64 => { let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_147(__inp, record, io_buffer, false)?; + let __out = aiur_fn_147(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 148u64 => { let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_148(__inp, record, io_buffer, false)?; + let __out = aiur_fn_148(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 149u64 => { let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_149(__inp, record, io_buffer, false)?; + let __out = aiur_fn_149(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 150u64 => { let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_150(__inp, record, io_buffer, false)?; + let __out = aiur_fn_150(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 151u64 => { let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_151(__inp, record, io_buffer, false)?; + let __out = aiur_fn_151(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 152u64 => { let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_152(__inp, record, io_buffer, false)?; + let __out = aiur_fn_152(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 153u64 => { let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_153(__inp, record, io_buffer, false)?; + let __out = aiur_fn_153(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 154u64 => { let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_154(__inp, record, io_buffer, false)?; + let __out = aiur_fn_154(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 155u64 => { let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_155(__inp, record, io_buffer, false)?; + let __out = aiur_fn_155(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 156u64 => { let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_156(__inp, record, io_buffer, false)?; + let __out = aiur_fn_156(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 157u64 => { let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_157(__inp, record, io_buffer, false)?; + let __out = aiur_fn_157(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 158u64 => { let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_158(__inp, record, io_buffer, false)?; + let __out = aiur_fn_158(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 159u64 => { let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_159(__inp, record, io_buffer, false)?; + let __out = aiur_fn_159(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 160u64 => { let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_160(__inp, record, io_buffer, false)?; + let __out = aiur_fn_160(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 161u64 => { let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_161(__inp, record, io_buffer, false)?; + let __out = aiur_fn_161(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 162u64 => { let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_162(__inp, record, io_buffer, false)?; + let __out = aiur_fn_162(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 163u64 => { let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_163(__inp, record, io_buffer, false)?; + let __out = aiur_fn_163(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 164u64 => { let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_164(__inp, record, io_buffer, false)?; + let __out = aiur_fn_164(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 165u64 => { let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_165(__inp, record, io_buffer, false)?; + let __out = aiur_fn_165(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 166u64 => { let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_166(__inp, record, io_buffer, false)?; + let __out = aiur_fn_166(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 167u64 => { let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_167(__inp, record, io_buffer, false)?; + let __out = aiur_fn_167(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 168u64 => { let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_168(__inp, record, io_buffer, false)?; + let __out = aiur_fn_168(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 169u64 => { let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_169(__inp, record, io_buffer, false)?; + let __out = aiur_fn_169(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 170u64 => { let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_170(__inp, record, io_buffer, false)?; + let __out = aiur_fn_170(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 171u64 => { let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_171(__inp, record, io_buffer, false)?; + let __out = aiur_fn_171(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 172u64 => { let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_172(__inp, record, io_buffer, false)?; + let __out = aiur_fn_172(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 173u64 => { let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_173(__inp, record, io_buffer, false)?; + let __out = aiur_fn_173(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 174u64 => { let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_174(__inp, record, io_buffer, false)?; + let __out = aiur_fn_174(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 175u64 => { let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_175(__inp, record, io_buffer, false)?; + let __out = aiur_fn_175(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 176u64 => { let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_176(__inp, record, io_buffer, false)?; + let __out = aiur_fn_176(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 177u64 => { let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_177(__inp, record, io_buffer, false)?; + let __out = aiur_fn_177(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 178u64 => { let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_178(__inp, record, io_buffer, false)?; + let __out = aiur_fn_178(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 179u64 => { let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_179(__inp, record, io_buffer, false)?; + let __out = aiur_fn_179(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 180u64 => { let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_180(__inp, record, io_buffer, false)?; + let __out = aiur_fn_180(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 181u64 => { let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_181(__inp, record, io_buffer, false)?; + let __out = aiur_fn_181(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 182u64 => { let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_182(__inp, record, io_buffer, false)?; + let __out = aiur_fn_182(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 183u64 => { let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_183(__inp, record, io_buffer, false)?; + let __out = aiur_fn_183(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 184u64 => { let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_184(__inp, record, io_buffer, false)?; + let __out = aiur_fn_184(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 185u64 => { let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_185(__inp, record, io_buffer, false)?; + let __out = aiur_fn_185(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 186u64 => { let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_186(__inp, record, io_buffer, false)?; + let __out = aiur_fn_186(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 187u64 => { let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_187(__inp, record, io_buffer, false)?; + let __out = aiur_fn_187(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 188u64 => { let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_188(__inp, record, io_buffer, false)?; + let __out = aiur_fn_188(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 189u64 => { let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_189(__inp, record, io_buffer, false)?; + let __out = aiur_fn_189(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 190u64 => { let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_190(__inp, record, io_buffer, false)?; + let __out = aiur_fn_190(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 191u64 => { let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_191(__inp, record, io_buffer, false)?; + let __out = aiur_fn_191(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 192u64 => { let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_192(__inp, record, io_buffer, false)?; + let __out = aiur_fn_192(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 193u64 => { let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_193(__inp, record, io_buffer, false)?; + let __out = aiur_fn_193(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 194u64 => { let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_194(__inp, record, io_buffer, false)?; + let __out = aiur_fn_194(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 195u64 => { let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_195(__inp, record, io_buffer, false)?; + let __out = aiur_fn_195(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 196u64 => { let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_196(__inp, record, io_buffer, false)?; + let __out = aiur_fn_196(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 197u64 => { let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_197(__inp, record, io_buffer, false)?; + let __out = aiur_fn_197(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 198u64 => { let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_198(__inp, record, io_buffer, false)?; + let __out = aiur_fn_198(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 199u64 => { let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_199(__inp, record, io_buffer, false)?; + let __out = aiur_fn_199(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 200u64 => { let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_200(__inp, record, io_buffer, false)?; + let __out = aiur_fn_200(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 201u64 => { let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_201(__inp, record, io_buffer, false)?; + let __out = aiur_fn_201(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 202u64 => { let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_202(__inp, record, io_buffer, false)?; + let __out = aiur_fn_202(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 203u64 => { let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_203(__inp, record, io_buffer, false)?; + let __out = aiur_fn_203(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 204u64 => { let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_204(__inp, record, io_buffer, false)?; + let __out = aiur_fn_204(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 205u64 => { let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_205(__inp, record, io_buffer, false)?; + let __out = aiur_fn_205(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 206u64 => { let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_206(__inp, record, io_buffer, false)?; + let __out = aiur_fn_206(QueryKey::new(__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)?; + let __out = aiur_fn_207(QueryKey::new(__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)?; + let __out = aiur_fn_208(QueryKey::new(__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)?; + let __out = aiur_fn_209(QueryKey::new(__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)?; + let __out = aiur_fn_210(QueryKey::new(__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)?; + let __out = aiur_fn_211(QueryKey::new(__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)?; + let __out = aiur_fn_212(QueryKey::new(__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)?; + let __out = aiur_fn_213(QueryKey::new(__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)?; + let __out = aiur_fn_214(QueryKey::new(__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)?; + let __out = aiur_fn_215(QueryKey::new(__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)?; + let __out = aiur_fn_216(QueryKey::new(__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)?; + let __out = aiur_fn_217(QueryKey::new(__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)?; + let __out = aiur_fn_218(QueryKey::new(__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)?; + let __out = aiur_fn_219(QueryKey::new(__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)?; + let __out = aiur_fn_220(QueryKey::new(__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)?; + let __out = aiur_fn_221(QueryKey::new(__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)?; + let __out = aiur_fn_222(QueryKey::new(__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)?; + let __out = aiur_fn_223(QueryKey::new(__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)?; + let __out = aiur_fn_224(QueryKey::new(__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)?; + let __out = aiur_fn_225(QueryKey::new(__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)?; + let __out = aiur_fn_226(QueryKey::new(__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)?; + let __out = aiur_fn_227(QueryKey::new(__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)?; + let __out = aiur_fn_228(QueryKey::new(__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)?; + let __out = aiur_fn_229(QueryKey::new(__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)?; + let __out = aiur_fn_230(QueryKey::new(__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)?; + let __out = aiur_fn_231(QueryKey::new(__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)?; + let __out = aiur_fn_232(QueryKey::new(__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)?; + let __out = aiur_fn_233(QueryKey::new(__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)?; + let __out = aiur_fn_234(QueryKey::new(__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)?; + let __out = aiur_fn_235(QueryKey::new(__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)?; + let __out = aiur_fn_236(QueryKey::new(__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)?; + let __out = aiur_fn_237(QueryKey::new(__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)?; + let __out = aiur_fn_238(QueryKey::new(__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)?; + let __out = aiur_fn_239(QueryKey::new(__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)?; + let __out = aiur_fn_240(QueryKey::new(__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)?; + let __out = aiur_fn_241(QueryKey::new(__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)?; + let __out = aiur_fn_242(QueryKey::new(__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)?; + let __out = aiur_fn_243(QueryKey::new(__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)?; + let __out = aiur_fn_244(QueryKey::new(__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)?; + let __out = aiur_fn_245(QueryKey::new(__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)?; + let __out = aiur_fn_246(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 247u64 => { let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_247(__inp, record, io_buffer, false)?; + let __out = aiur_fn_247(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 248u64 => { let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_248(__inp, record, io_buffer, false)?; + let __out = aiur_fn_248(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 249u64 => { let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_249(__inp, record, io_buffer, false)?; + let __out = aiur_fn_249(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 250u64 => { let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_250(__inp, record, io_buffer, false)?; + let __out = aiur_fn_250(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 251u64 => { let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_251(__inp, record, io_buffer, false)?; + let __out = aiur_fn_251(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 252u64 => { let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_252(__inp, record, io_buffer, false)?; + let __out = aiur_fn_252(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 253u64 => { let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_253(__inp, record, io_buffer, false)?; + let __out = aiur_fn_253(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 254u64 => { let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_254(__inp, record, io_buffer, false)?; + let __out = aiur_fn_254(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 255u64 => { let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_255(__inp, record, io_buffer, false)?; + let __out = aiur_fn_255(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_256(__inp, record, io_buffer, false)?; + let __out = aiur_fn_256(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_257(__inp, record, io_buffer, false)?; + let __out = aiur_fn_257(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_258(__inp, record, io_buffer, false)?; + let __out = aiur_fn_258(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 259u64 => { let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_259(__inp, record, io_buffer, false)?; + let __out = aiur_fn_259(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 260u64 => { let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_260(__inp, record, io_buffer, false)?; + let __out = aiur_fn_260(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 261u64 => { let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_261(__inp, record, io_buffer, false)?; + let __out = aiur_fn_261(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, _ => { diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs index 81ca667e9..b3177c759 100644 --- a/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs +++ b/crates/ixvm-codegen/src/aiur_ix_aggr_runner.rs @@ -217,7 +217,9 @@ pub fn execute_ix_aggr( return Err(ExecError::NotEntryFunction(fun_idx)); } let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; + let output = execute_generated(fun_idx, &args, &mut record, io_buffer) + .map_err(|e| record.execution_error(e))?; + record.log_multiplicity_stats("returned"); Ok((record, output)) } diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 5b0acaf94..2919870d3 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -14,23 +14,25 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; +use aiur::querymap::QueryKey; use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_xor_split7_value, bytes2_xor_split4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; fn aiur_fn_0( - inp: [G; IN_0], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(0); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __ret: [G; OUT_0] = [__v_2]; - record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[0].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -39,15 +41,16 @@ const INPUT_SIZE_1: usize = 2; const IN_1: usize = 2; const OUT_1: usize = 1; fn aiur_fn_1( - inp: [G; IN_1], + inp: QueryKey, 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(1); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -80,7 +83,7 @@ fn aiur_fn_1( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -286,13 +289,13 @@ fn aiur_fn_1( 0u64 => { let __v_227: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_227]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_227]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -300,7 +303,7 @@ fn aiur_fn_1( _ => { let __v_214: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_214]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -308,7 +311,7 @@ fn aiur_fn_1( _ => { let __v_177: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_177]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -316,7 +319,7 @@ fn aiur_fn_1( _ => { let __v_140: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_140]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -324,7 +327,7 @@ fn aiur_fn_1( _ => { let __v_103: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_103]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -335,15 +338,16 @@ const INPUT_SIZE_2: usize = 2; const IN_2: usize = 2; const OUT_2: usize = 1; fn aiur_fn_2( - inp: [G; IN_2], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(2); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -376,7 +380,7 @@ fn aiur_fn_2( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -412,16 +416,16 @@ fn aiur_fn_2( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[1].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[1].bump_multiplicity(__i)?; } record.function_queries[1].output_at(__i).to_array::() }, _ => aiur_fn_1(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; - record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[2].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; - record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[2].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -432,22 +436,23 @@ const INPUT_SIZE_3: usize = 3; const IN_3: usize = 3; const OUT_3: usize = 1; fn aiur_fn_3( - inp: [G; IN_3], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(3); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_3] = [__v_5]; - record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[3].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -455,14 +460,14 @@ fn aiur_fn_3( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[3].bump_multiplicity(__i)?; } record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_3] = [__v_10]; - record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[3].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -473,20 +478,21 @@ const INPUT_SIZE_4: usize = 8; const IN_4: usize = 8; const OUT_4: usize = 1; fn aiur_fn_4( - inp: [G; IN_4], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(4); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_1.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { @@ -503,13 +509,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -519,13 +525,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -539,13 +545,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -555,13 +561,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -579,13 +585,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -595,13 +601,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -615,13 +621,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -631,13 +637,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -659,13 +665,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -675,13 +681,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -695,13 +701,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -711,13 +717,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -735,13 +741,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -751,13 +757,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -771,13 +777,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -787,13 +793,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -819,13 +825,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(3); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -835,13 +841,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -855,13 +861,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -871,13 +877,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -895,13 +901,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -911,13 +917,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -931,13 +937,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -947,13 +953,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -975,13 +981,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -991,13 +997,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1011,13 +1017,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1027,13 +1033,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1051,13 +1057,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1067,13 +1073,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1087,13 +1093,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1103,13 +1109,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1139,13 +1145,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(2); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1155,13 +1161,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1175,13 +1181,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1191,13 +1197,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1215,13 +1221,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1231,13 +1237,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1251,13 +1257,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1267,13 +1273,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1295,13 +1301,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1311,13 +1317,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1331,13 +1337,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1347,13 +1353,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1371,13 +1377,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1387,13 +1393,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1407,13 +1413,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1423,13 +1429,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1455,13 +1461,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(3); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1471,13 +1477,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1491,13 +1497,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1507,13 +1513,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1531,13 +1537,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1547,13 +1553,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1567,13 +1573,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1583,13 +1589,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1611,13 +1617,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(4); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1627,13 +1633,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1647,13 +1653,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1663,13 +1669,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1687,13 +1693,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(5); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1703,13 +1709,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1723,13 +1729,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(6); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1739,13 +1745,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(7); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1768,20 +1774,21 @@ const INPUT_SIZE_5: usize = 8; const IN_5: usize = 8; const OUT_5: usize = 1; fn aiur_fn_5( - inp: [G; IN_5], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(5); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { @@ -1800,13 +1807,13 @@ fn aiur_fn_5( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1814,7 +1821,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1822,7 +1829,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1830,7 +1837,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1838,7 +1845,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1846,7 +1853,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1854,7 +1861,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1862,7 +1869,7 @@ fn aiur_fn_5( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_5] = [__v_8]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1873,20 +1880,21 @@ const INPUT_SIZE_6: usize = 8; const IN_6: usize = 8; const OUT_6: usize = 4; fn aiur_fn_6( - inp: [G; IN_6], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(6); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); @@ -1894,14 +1902,14 @@ fn aiur_fn_6( let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_13: G = (__v_12 * __v_12); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_6] = [__v_8, __v_9, __v_10, __v_11]; - record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[6].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1910,24 +1918,25 @@ const INPUT_SIZE_7: usize = 12; const IN_7: usize = 12; const OUT_7: usize = 4; fn aiur_fn_7( - inp: [G; IN_7], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __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]; + record.checkpoint(7); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); @@ -1935,8 +1944,8 @@ fn aiur_fn_7( let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_12; let __vj = __v_13; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_14; let __vj = __v_15; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_u64(2); @@ -1948,7 +1957,7 @@ fn aiur_fn_7( 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_7] = [__v_12, __v_13, __v_14, __v_15]; - record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[7].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1957,26 +1966,27 @@ const INPUT_SIZE_8: usize = 8; const IN_8: usize = 8; const OUT_8: usize = 4; fn aiur_fn_8( - inp: [G; IN_8], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) }; - let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; - let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; - let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; + record.checkpoint(8); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record)? }; + let __v_9: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record)? }; + let __v_10: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record)? }; + let __v_11: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record)? }; let __ret: [G; OUT_8] = [__v_8, __v_9, __v_10, __v_11]; - record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[8].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1985,18 +1995,19 @@ const INPUT_SIZE_9: usize = 4; const IN_9: usize = 4; const OUT_9: usize = 4; fn aiur_fn_9( - inp: [G; IN_9], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(9); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __ret: [G; OUT_9] = [__v_2, __v_3, __v_0, __v_1]; - record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[9].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2005,18 +2016,19 @@ const INPUT_SIZE_10: usize = 4; const IN_10: usize = 4; const OUT_10: usize = 4; fn aiur_fn_10( - inp: [G; IN_10], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(10); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __ret: [G; OUT_10] = [__v_1, __v_2, __v_3, __v_0]; - record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[10].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2025,30 +2037,31 @@ const INPUT_SIZE_11: usize = 8; const IN_11: usize = 8; const OUT_11: usize = 4; fn aiur_fn_11( - inp: [G; IN_11], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record) }; + record.checkpoint(11); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record)? }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record)? }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record)? }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record)? }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); @@ -2056,7 +2069,7 @@ fn aiur_fn_11( let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; - record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[11].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2065,30 +2078,31 @@ const INPUT_SIZE_12: usize = 8; const IN_12: usize = 8; const OUT_12: usize = 4; fn aiur_fn_12( - inp: [G; IN_12], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record) }; + record.checkpoint(12); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record)? }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record)? }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record)? }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record)? }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); @@ -2096,7 +2110,7 @@ fn aiur_fn_12( let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_12] = [__v_16, __v_17, __v_18, __v_19]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2105,28 +2119,29 @@ const INPUT_SIZE_13: usize = 16; const IN_13: usize = 16; const OUT_13: usize = 1; fn aiur_fn_13( - inp: [G; IN_13], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = 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]; + record.checkpoint(13); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; let __v_16: G = (__v_0 - __v_8); let __v_17: G = (__v_1 - __v_9); let __v_18: G = (__v_2 - __v_10); @@ -2153,13 +2168,13 @@ fn aiur_fn_13( 0u64 => { let __v_24: G = G::from_u64(1); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2167,7 +2182,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2175,7 +2190,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2183,7 +2198,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2191,7 +2206,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2199,7 +2214,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2207,7 +2222,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2215,7 +2230,7 @@ fn aiur_fn_13( _ => { let __v_24: G = G::from_u64(0); let __ret: [G; OUT_13] = [__v_24]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2226,82 +2241,83 @@ const INPUT_SIZE_14: usize = 16; const IN_14: usize = 16; const OUT_14: usize = 9; fn aiur_fn_14( - inp: [G; IN_14], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = 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 __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_8) } else { bytes2_add_value(__v_0, __v_8, record) }; + record.checkpoint(14); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::add(&__v_0, &__v_8) } else { bytes2_add_value(__v_0, __v_8, record)? }; let __v_16: G = __b2_add.0; let __v_17: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_9) } else { bytes2_add_value(__v_1, __v_9, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_9)?; Bytes2::add(&__v_1, &__v_9) } else { bytes2_add_value(__v_1, __v_9, record)? }; let __v_18: G = __b2_add.0; let __v_19: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_18, &__v_17) } else { bytes2_add_value(__v_18, __v_17, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_17)?; Bytes2::add(&__v_18, &__v_17) } else { bytes2_add_value(__v_18, __v_17, record)? }; let __v_20: G = __b2_add.0; let __v_21: G = __b2_add.1; let __v_22: G = (__v_19 + __v_21); - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_10) } else { bytes2_add_value(__v_2, __v_10, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_10)?; Bytes2::add(&__v_2, &__v_10) } else { bytes2_add_value(__v_2, __v_10, record)? }; let __v_23: G = __b2_add.0; let __v_24: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_23, &__v_22) } else { bytes2_add_value(__v_23, __v_22, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_22)?; Bytes2::add(&__v_23, &__v_22) } else { bytes2_add_value(__v_23, __v_22, record)? }; let __v_25: G = __b2_add.0; let __v_26: G = __b2_add.1; let __v_27: G = (__v_24 + __v_26); - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_11) } else { bytes2_add_value(__v_3, __v_11, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_11)?; Bytes2::add(&__v_3, &__v_11) } else { bytes2_add_value(__v_3, __v_11, record)? }; let __v_28: G = __b2_add.0; let __v_29: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_27) } else { bytes2_add_value(__v_28, __v_27, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_27)?; Bytes2::add(&__v_28, &__v_27) } else { bytes2_add_value(__v_28, __v_27, record)? }; let __v_30: G = __b2_add.0; let __v_31: G = __b2_add.1; let __v_32: G = (__v_29 + __v_31); - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_4, &__v_12) } else { bytes2_add_value(__v_4, __v_12, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_12)?; Bytes2::add(&__v_4, &__v_12) } else { bytes2_add_value(__v_4, __v_12, record)? }; let __v_33: G = __b2_add.0; let __v_34: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_32) } else { bytes2_add_value(__v_33, __v_32, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_33, &__v_32)?; Bytes2::add(&__v_33, &__v_32) } else { bytes2_add_value(__v_33, __v_32, record)? }; let __v_35: G = __b2_add.0; let __v_36: G = __b2_add.1; let __v_37: G = (__v_34 + __v_36); - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_5, &__v_13) } else { bytes2_add_value(__v_5, __v_13, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_13)?; Bytes2::add(&__v_5, &__v_13) } else { bytes2_add_value(__v_5, __v_13, record)? }; let __v_38: G = __b2_add.0; let __v_39: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_37) } else { bytes2_add_value(__v_38, __v_37, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_38, &__v_37)?; Bytes2::add(&__v_38, &__v_37) } else { bytes2_add_value(__v_38, __v_37, record)? }; let __v_40: G = __b2_add.0; let __v_41: G = __b2_add.1; let __v_42: G = (__v_39 + __v_41); - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_6, &__v_14) } else { bytes2_add_value(__v_6, __v_14, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_14)?; Bytes2::add(&__v_6, &__v_14) } else { bytes2_add_value(__v_6, __v_14, record)? }; let __v_43: G = __b2_add.0; let __v_44: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_43, &__v_42) } else { bytes2_add_value(__v_43, __v_42, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_43, &__v_42)?; Bytes2::add(&__v_43, &__v_42) } else { bytes2_add_value(__v_43, __v_42, record)? }; let __v_45: G = __b2_add.0; let __v_46: G = __b2_add.1; let __v_47: G = (__v_44 + __v_46); - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_7, &__v_15) } else { bytes2_add_value(__v_7, __v_15, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_15)?; Bytes2::add(&__v_7, &__v_15) } else { bytes2_add_value(__v_7, __v_15, record)? }; let __v_48: G = __b2_add.0; let __v_49: G = __b2_add.1; - let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_48, &__v_47) } else { bytes2_add_value(__v_48, __v_47, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_48, &__v_47)?; Bytes2::add(&__v_48, &__v_47) } else { bytes2_add_value(__v_48, __v_47, record)? }; let __v_50: G = __b2_add.0; let __v_51: G = __b2_add.1; let __v_52: G = (__v_49 + __v_51); let __ret: [G; OUT_14] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[14].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2310,20 +2326,21 @@ const INPUT_SIZE_15: usize = 8; const IN_15: usize = 8; const OUT_15: usize = 8; fn aiur_fn_15( - inp: [G; IN_15], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(15); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { @@ -2349,7 +2366,7 @@ fn aiur_fn_15( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -2363,7 +2380,7 @@ fn aiur_fn_15( let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2378,7 +2395,7 @@ fn aiur_fn_15( let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2392,7 +2409,7 @@ fn aiur_fn_15( let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2405,7 +2422,7 @@ fn aiur_fn_15( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2417,7 +2434,7 @@ fn aiur_fn_15( let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2428,7 +2445,7 @@ fn aiur_fn_15( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_15] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2438,7 +2455,7 @@ fn aiur_fn_15( let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_15] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2447,7 +2464,7 @@ fn aiur_fn_15( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_15] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2458,20 +2475,21 @@ const INPUT_SIZE_16: usize = 8; const IN_16: usize = 8; const OUT_16: usize = 8; fn aiur_fn_16( - inp: [G; IN_16], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(16); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { @@ -2497,7 +2515,7 @@ fn aiur_fn_16( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -2511,7 +2529,7 @@ fn aiur_fn_16( let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 - __v_15); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2526,7 +2544,7 @@ fn aiur_fn_16( let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 - __v_14); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2540,7 +2558,7 @@ fn aiur_fn_16( let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 - __v_13); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2553,7 +2571,7 @@ fn aiur_fn_16( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 - __v_12); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2565,7 +2583,7 @@ fn aiur_fn_16( let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2576,7 +2594,7 @@ fn aiur_fn_16( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); let __ret: [G; OUT_16] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2586,7 +2604,7 @@ fn aiur_fn_16( let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); let __ret: [G; OUT_16] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2595,7 +2613,7 @@ fn aiur_fn_16( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 - __v_8); let __ret: [G; OUT_16] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2606,20 +2624,21 @@ const INPUT_SIZE_17: usize = 8; const IN_17: usize = 8; const OUT_17: usize = 1; fn aiur_fn_17( - inp: [G; IN_17], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(17); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); @@ -2643,7 +2662,7 @@ fn aiur_fn_17( let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_17] = [__v_26]; - record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[17].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2652,16 +2671,17 @@ const INPUT_SIZE_18: usize = 4; const IN_18: usize = 4; const OUT_18: usize = 1; fn aiur_fn_18( - inp: [G; IN_18], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(18); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); @@ -2672,7 +2692,7 @@ fn aiur_fn_18( let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_18] = [__v_12]; - record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[18].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2681,44 +2701,45 @@ const INPUT_SIZE_19: usize = 32; const IN_19: usize = 32; const OUT_19: usize = 8; fn aiur_fn_19( - inp: [G; IN_19], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(19); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = G::from_u64(65536); @@ -2792,7 +2813,7 @@ fn aiur_fn_19( let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_28 + __v_102); let __ret: [G; OUT_19] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; - record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[19].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2801,13 +2822,14 @@ const INPUT_SIZE_20: usize = 1; const IN_20: usize = 1; const OUT_20: usize = 32; fn aiur_fn_20( - inp: [G; IN_20], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(20); + let __v_0: G = inp.values()[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); @@ -2842,7 +2864,7 @@ fn aiur_fn_20( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -2853,14 +2875,14 @@ fn aiur_fn_20( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[24].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i)?; } record.function_queries[24].output_at(__i).to_array::() }, _ => aiur_fn_24(__key, 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]; @@ -2894,7 +2916,7 @@ fn aiur_fn_20( let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __ret: [G; OUT_20] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; - record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[20].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2903,45 +2925,46 @@ const INPUT_SIZE_21: usize = 33; const IN_21: usize = 33; const OUT_21: usize = 0; fn aiur_fn_21( - inp: [G; IN_21], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; + record.checkpoint(21); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; let __v_33: G = G::from_u64(103); let __v_34: G = G::from_u64(230); let __v_35: G = G::from_u64(9); @@ -2976,7 +2999,7 @@ fn aiur_fn_21( let __v_64: G = G::from_u64(91); let __v_65: G = G::from_u64(1); let __v_66: G = G::from_u64(1); - let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_68: G = G::from_u64(0); let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -2987,14 +3010,14 @@ fn aiur_fn_21( let __v_75: G = G::from_u64(0); let __v_76: G = G::from_u64(0); let __v_77: G = G::from_u64(0); - let __v_78: G = { let __values: [G; 8] = [__v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_79: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = { let __values: [G; 8] = [__v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_79: G = { let __values: [G; 32] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_80: G = G::from_u64(1); let __v_81: G = G::from_u64(1); - let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_82: G = { let __values: [G; 34] = [__v_80, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_67, __v_68, __v_69, __v_78, __v_79, __v_82]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_83]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[24].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i)?; } record.function_queries[24].output_at(__i).to_array::() }, _ => aiur_fn_24(__key, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; @@ -3124,7 +3147,7 @@ fn aiur_fn_21( return Err(ExecError::AssertEqMismatch { lhs: __v_115.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("blake3 of the supplied bytes != the address they were fetched under".to_string()) }); } let __ret: [G; OUT_21] = []; - record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[21].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -3133,13 +3156,14 @@ const INPUT_SIZE_22: usize = 1; const IN_22: usize = 1; const OUT_22: usize = 1; fn aiur_fn_22( - inp: [G; IN_22], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(22); + let __v_0: G = inp.values()[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); @@ -3174,7 +3198,7 @@ fn aiur_fn_22( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -3185,14 +3209,14 @@ fn aiur_fn_22( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[24].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i)?; } record.function_queries[24].output_at(__i).to_array::() }, _ => aiur_fn_24(__key, 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]; @@ -3225,9 +3249,9 @@ fn aiur_fn_22( let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; - let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_22] = [__v_84]; - record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[22].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -3236,47 +3260,48 @@ const INPUT_SIZE_23: usize = 34; const IN_23: usize = 34; const OUT_23: usize = 34; fn aiur_fn_23( - inp: [G; IN_23], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + record.checkpoint(23); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -3315,12 +3340,12 @@ fn aiur_fn_23( 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_23] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; - record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[23].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[23].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[23].bump_multiplicity(__i)?; } record.function_queries[23].output_at(__i).to_array::() }, _ => aiur_fn_23(__key, 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]; @@ -3359,7 +3384,7 @@ fn aiur_fn_23( 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_23] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; - record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[23].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -3397,7 +3422,7 @@ fn aiur_fn_23( let __v_134: G = G::from_u64(205); let __v_135: G = G::from_u64(224); let __v_136: G = G::from_u64(91); - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -3468,7 +3493,7 @@ fn aiur_fn_23( 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_33] = { let __args: [G; IN_33] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -3504,9 +3529,9 @@ fn aiur_fn_23( let __v_237: G = G::from_u64(0); let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); - let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_23] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; - record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[23].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3542,7 +3567,7 @@ fn aiur_fn_23( 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_33] = { let __args: [G; IN_33] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -3578,9 +3603,9 @@ fn aiur_fn_23( let __v_235: G = G::from_u64(0); let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); - let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_23] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; - record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[23].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -3601,14 +3626,15 @@ const INPUT_SIZE_24: usize = 1; const IN_24: usize = 1; const OUT_24: usize = 32; fn aiur_fn_24( - inp: [G; IN_24], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + record.checkpoint(24); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -3645,7 +3671,7 @@ fn aiur_fn_24( let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -3683,12 +3709,12 @@ fn aiur_fn_24( match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_24] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[24].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[23].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[23].bump_multiplicity(__i); } let __ret: [G; OUT_23] = unsafe { *(record.function_queries[23].output_at(__i).as_ptr() as *const [G; OUT_23]) }; __ret }, _ => aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[23].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[23].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[23].bump_multiplicity(__i)?; } record.function_queries[23].output_at(__i).to_array::() }, _ => aiur_fn_23(__key, 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]; @@ -3725,7 +3751,7 @@ fn aiur_fn_24( let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_103]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_103]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[24].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i)?; } record.function_queries[24].output_at(__i).to_array::() }, _ => aiur_fn_24(__key, 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]; @@ -3759,13 +3785,13 @@ fn aiur_fn_24( let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_24] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; - record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[24].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[24].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i)?; } record.function_queries[24].output_at(__i).to_array::() }, _ => aiur_fn_24(__key, 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]; @@ -3799,7 +3825,7 @@ fn aiur_fn_24( let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_24] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; - record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[24].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3820,40 +3846,41 @@ const INPUT_SIZE_25: usize = 7; const IN_25: usize = 7; const OUT_25: usize = 1; fn aiur_fn_25( - inp: [G; IN_25], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(25); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[28].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[28].bump_multiplicity(__i); } let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[28].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[28].bump_multiplicity(__i)?; } record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_10]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[29].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[29].bump_multiplicity(__i); } let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[29].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[29].bump_multiplicity(__i)?; } record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_12]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3861,10 +3888,10 @@ fn aiur_fn_25( 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_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_25] = [__v_16]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -3880,399 +3907,400 @@ const INPUT_SIZE_26: usize = 1; const IN_26: usize = 1; const OUT_26: usize = 64; fn aiur_fn_26( - inp: [G; IN_26], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(26); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_26] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[26].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -4601,30 +4629,31 @@ const INPUT_SIZE_27: usize = 2; const IN_27: usize = 2; const OUT_27: usize = 1; fn aiur_fn_27( - inp: [G; IN_27], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(27); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_27] = [__v_0]; - record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[27].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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_27] = { let __args: [G; IN_27] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_7]; - record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[27].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -4635,18 +4664,19 @@ const INPUT_SIZE_28: usize = 6; const IN_28: usize = 6; const OUT_28: usize = 1; fn aiur_fn_28( - inp: [G; IN_28], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(28); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); @@ -4654,7 +4684,7 @@ fn aiur_fn_28( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4681,7 +4711,7 @@ fn aiur_fn_28( 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -4778,7 +4808,7 @@ fn aiur_fn_28( let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; @@ -4812,7 +4842,7 @@ fn aiur_fn_28( 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_33] = { let __args: [G; IN_33] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -4845,70 +4875,70 @@ fn aiur_fn_28( let __v_177: G = __r_arr[29]; let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; - let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_28] = [__v_180]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_28] = [__v_5]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -4941,15 +4971,15 @@ fn aiur_fn_28( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_28] = [__v_42]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4958,7 +4988,7 @@ fn aiur_fn_28( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, 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); @@ -4968,9 +4998,9 @@ fn aiur_fn_28( 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_27] = { let __args: [G; IN_27] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[26].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i)?; } record.function_queries[26].output_at(__i).to_array::() }, _ => aiur_fn_26(__key, 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]; @@ -5035,7 +5065,7 @@ fn aiur_fn_28( let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; @@ -5068,7 +5098,7 @@ fn aiur_fn_28( let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_123: G = __loaded[0]; let __v_124: G = __loaded[1]; let __v_125: G = __loaded[2]; @@ -5101,7 +5131,7 @@ fn aiur_fn_28( 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_33] = { let __args: [G; IN_33] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -5134,9 +5164,9 @@ fn aiur_fn_28( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_28] = [__v_187]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -5147,22 +5177,23 @@ const INPUT_SIZE_29: usize = 6; const IN_29: usize = 6; const OUT_29: usize = 1; fn aiur_fn_29( - inp: [G; IN_29], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(29); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[26].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i)?; } record.function_queries[26].output_at(__i).to_array::() }, _ => aiur_fn_26(__key, 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]; @@ -5229,9 +5260,9 @@ fn aiur_fn_29( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[778].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i)?; } record.function_queries[778].output_at(__i).to_array::() }, _ => aiur_fn_778(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; @@ -5240,7 +5271,7 @@ fn aiur_fn_29( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, 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); @@ -5277,7 +5308,7 @@ fn aiur_fn_29( let __v_115: G = G::from_u64(205); let __v_116: G = G::from_u64(224); let __v_117: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; @@ -5310,7 +5341,7 @@ fn aiur_fn_29( let __v_147: G = __loaded[29]; let __v_148: G = __loaded[30]; let __v_149: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_150: G = __loaded[0]; let __v_151: G = __loaded[1]; let __v_152: G = __loaded[2]; @@ -5344,7 +5375,7 @@ fn aiur_fn_29( 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_33] = { let __args: [G; IN_33] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -5377,13 +5408,13 @@ fn aiur_fn_29( let __v_212: G = __r_arr[29]; let __v_213: G = __r_arr[30]; let __v_214: G = __r_arr[31]; - let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_216: G = G::from_u64(1); let __v_217: G = G::from_u64(1); - let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_219: G = G::from_u64(0); let __v_220: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_221: G = __loaded[0]; let __v_222: G = __loaded[1]; let __v_223: G = __loaded[2]; @@ -5392,7 +5423,7 @@ fn aiur_fn_29( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -5401,21 +5432,21 @@ fn aiur_fn_29( let __v_234: G = __r_arr[5]; let __v_235: G = __r_arr[6]; let __v_236: G = __r_arr[7]; - let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_239: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_239]; - record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[29].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[778].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i)?; } record.function_queries[778].output_at(__i).to_array::() }, _ => aiur_fn_778(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[778].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i)?; } record.function_queries[778].output_at(__i).to_array::() }, _ => aiur_fn_778(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; @@ -5424,7 +5455,7 @@ fn aiur_fn_29( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, 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); @@ -5434,7 +5465,7 @@ fn aiur_fn_29( let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; @@ -5467,7 +5498,7 @@ fn aiur_fn_29( let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_125: G = __loaded[0]; let __v_126: G = __loaded[1]; let __v_127: G = __loaded[2]; @@ -5500,7 +5531,7 @@ fn aiur_fn_29( 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_33] = { let __args: [G; IN_33] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -5535,15 +5566,15 @@ fn aiur_fn_29( let __v_188: G = __r_arr[31]; let __v_189: G = G::from_u64(1); let __v_190: G = G::from_u64(1); - let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_192: G = G::from_u64(0); let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); - let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_29] = [__v_196]; - record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[29].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -5554,36 +5585,37 @@ const INPUT_SIZE_30: usize = 24; const IN_30: usize = 24; const OUT_30: usize = 16; fn aiur_fn_30( - inp: [G; IN_30], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; + record.checkpoint(30); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); @@ -5591,8 +5623,8 @@ fn aiur_fn_30( let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); @@ -5603,10 +5635,10 @@ fn aiur_fn_30( if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_36: G = if unconstrained { Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record) }; - let __v_37: G = if unconstrained { Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record) }; - let __v_38: G = if unconstrained { Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record) }; - let __v_39: G = if unconstrained { Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record) }; + let __v_36: G = if unconstrained { Bytes2::validate_inputs(&__v_12, &__v_24)?; Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record)? }; + let __v_37: G = if unconstrained { Bytes2::validate_inputs(&__v_13, &__v_25)?; Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record)? }; + let __v_38: G = if unconstrained { Bytes2::validate_inputs(&__v_14, &__v_26)?; Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record)? }; + let __v_39: G = if unconstrained { Bytes2::validate_inputs(&__v_15, &__v_27)?; Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record)? }; let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8) | (__v_36.as_canonical_u64() << 16) | (__v_37.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); @@ -5614,22 +5646,22 @@ fn aiur_fn_30( let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_40)?; Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record)? }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_41)?; Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record)? }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_42)?; Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record)? }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_43)?; Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record)? }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); @@ -5643,8 +5675,8 @@ fn aiur_fn_30( let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_63: G = G::from_u64(1); let __v_64: G = (__v_62 - __v_63); let __v_65: G = G::from_u64(2); @@ -5655,10 +5687,10 @@ fn aiur_fn_30( if (__v_68 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_70: G = if unconstrained { Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record) }; - let __v_71: G = if unconstrained { Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record) }; - let __v_72: G = if unconstrained { Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record) }; - let __v_73: G = if unconstrained { Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record) }; + let __v_70: G = if unconstrained { Bytes2::validate_inputs(&__v_38, &__v_58)?; Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record)? }; + let __v_71: G = if unconstrained { Bytes2::validate_inputs(&__v_39, &__v_59)?; Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record)? }; + let __v_72: G = if unconstrained { Bytes2::validate_inputs(&__v_36, &__v_60)?; Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record)? }; + let __v_73: G = if unconstrained { Bytes2::validate_inputs(&__v_37, &__v_61)?; Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record)? }; let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_71.as_canonical_u64() << 0) | (__v_72.as_canonical_u64() << 8) | (__v_73.as_canonical_u64() << 16) | (__v_70.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_74: G = G::from_u8(__u32_bytes[0]); @@ -5666,22 +5698,22 @@ fn aiur_fn_30( let __v_76: G = G::from_u8(__u32_bytes[2]); let __v_77: G = G::from_u8(__u32_bytes[3]); let __v_78: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_74; let __vj = __v_75; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_74; let __vj = __v_75; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_76; let __vj = __v_77; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_79: G = (__v_78 * __v_78); if (__v_79 != __v_78) { return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_74)?; Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record)? }; let __v_80: G = __b2_out.0; let __v_81: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_75)?; Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record)? }; let __v_82: G = __b2_out.0; let __v_83: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_76)?; Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record)? }; let __v_84: G = __b2_out.0; let __v_85: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_77)?; Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record)? }; let __v_86: G = __b2_out.0; let __v_87: G = __b2_out.1; let __v_88: G = (__v_80 + __v_83); @@ -5689,7 +5721,7 @@ fn aiur_fn_30( let __v_90: G = (__v_84 + __v_87); let __v_91: G = (__v_86 + __v_81); let __ret: [G; OUT_30] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; - record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[30].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -5698,140 +5730,141 @@ const INPUT_SIZE_31: usize = 128; const IN_31: usize = 128; const OUT_31: usize = 128; fn aiur_fn_31( - inp: [G; IN_31], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; - let __v_106: G = inp[106]; - let __v_107: G = inp[107]; - let __v_108: G = inp[108]; - let __v_109: G = inp[109]; - let __v_110: G = inp[110]; - let __v_111: G = inp[111]; - let __v_112: G = inp[112]; - let __v_113: G = inp[113]; - let __v_114: G = inp[114]; - let __v_115: G = inp[115]; - let __v_116: G = inp[116]; - let __v_117: G = inp[117]; - let __v_118: G = inp[118]; - let __v_119: G = inp[119]; - let __v_120: G = inp[120]; - let __v_121: G = inp[121]; - let __v_122: G = inp[122]; - let __v_123: G = inp[123]; - let __v_124: G = inp[124]; - let __v_125: G = inp[125]; - let __v_126: G = inp[126]; - let __v_127: G = inp[127]; + record.checkpoint(31); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; + let __v_106: G = inp.values()[106]; + let __v_107: G = inp.values()[107]; + let __v_108: G = inp.values()[108]; + let __v_109: G = inp.values()[109]; + let __v_110: G = inp.values()[110]; + let __v_111: G = inp.values()[111]; + let __v_112: G = inp.values()[112]; + let __v_113: G = inp.values()[113]; + let __v_114: G = inp.values()[114]; + let __v_115: G = inp.values()[115]; + let __v_116: G = inp.values()[116]; + let __v_117: G = inp.values()[117]; + let __v_118: G = inp.values()[118]; + let __v_119: G = inp.values()[119]; + let __v_120: G = inp.values()[120]; + let __v_121: G = inp.values()[121]; + let __v_122: G = inp.values()[122]; + let __v_123: G = inp.values()[123]; + let __v_124: G = inp.values()[124]; + let __v_125: G = inp.values()[125]; + let __v_126: G = inp.values()[126]; + let __v_127: G = inp.values()[127]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))) + u128::from(((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8) | (__v_66.as_canonical_u64() << 16) | (__v_67.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); @@ -5839,8 +5872,8 @@ fn aiur_fn_31( let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_128; let __vj = __v_129; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_130; let __vj = __v_131; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); @@ -5851,10 +5884,10 @@ fn aiur_fn_31( if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_140: G = if unconstrained { Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record) }; - let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) }; + let __v_140: G = if unconstrained { Bytes2::validate_inputs(&__v_48, &__v_128)?; Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record)? }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_49, &__v_129)?; Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_50, &__v_130)?; Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_51, &__v_131)?; Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record)? }; let __u32_sum: u128 = u128::from(((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8) | (__v_34.as_canonical_u64() << 16) | (__v_35.as_canonical_u64() << 24))) + u128::from(((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8) | (__v_140.as_canonical_u64() << 16) | (__v_141.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); @@ -5862,22 +5895,22 @@ fn aiur_fn_31( let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_144; let __vj = __v_145; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_146; let __vj = __v_147; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_144)?; Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record)? }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_145)?; Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record)? }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_146)?; Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record)? }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_147)?; Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record)? }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); @@ -5891,8 +5924,8 @@ fn aiur_fn_31( let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_162; let __vj = __v_163; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_164; let __vj = __v_165; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_167: G = G::from_u64(1); let __v_168: G = (__v_166 - __v_167); let __v_169: G = G::from_u64(2); @@ -5903,10 +5936,10 @@ fn aiur_fn_31( if (__v_172 != __v_173) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_174: G = if unconstrained { Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record) }; - let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) }; - let __v_176: G = if unconstrained { Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record) }; - let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) }; + let __v_174: G = if unconstrained { Bytes2::validate_inputs(&__v_142, &__v_162)?; Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record)? }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_143, &__v_163)?; Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record)? }; + let __v_176: G = if unconstrained { Bytes2::validate_inputs(&__v_140, &__v_164)?; Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record)? }; + let __v_177: G = if unconstrained { Bytes2::validate_inputs(&__v_141, &__v_165)?; Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record)? }; let __u32_sum: u128 = u128::from(((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8) | (__v_146.as_canonical_u64() << 16) | (__v_147.as_canonical_u64() << 24))) + u128::from(((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8) | (__v_177.as_canonical_u64() << 16) | (__v_174.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_178: G = G::from_u8(__u32_bytes[0]); @@ -5914,22 +5947,22 @@ fn aiur_fn_31( let __v_180: G = G::from_u8(__u32_bytes[2]); let __v_181: G = G::from_u8(__u32_bytes[3]); let __v_182: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_180; let __vj = __v_181; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_178; let __vj = __v_179; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_180; let __vj = __v_181; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_183: G = (__v_182 * __v_182); if (__v_183 != __v_182) { return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_158, &__v_178)?; Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record)? }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_159, &__v_179)?; Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record)? }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_160, &__v_180)?; Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record)? }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_161, &__v_181)?; Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record)? }; let __v_190: G = __b2_out.0; let __v_191: G = __b2_out.1; let __v_192: G = (__v_184 + __v_187); @@ -5943,8 +5976,8 @@ fn aiur_fn_31( let __v_198: G = G::from_u8(__u32_bytes[2]); let __v_199: G = G::from_u8(__u32_bytes[3]); let __v_200: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_196; let __vj = __v_197; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_198; let __vj = __v_199; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_201: G = G::from_u64(1); let __v_202: G = (__v_200 - __v_201); let __v_203: G = G::from_u64(2); @@ -5955,10 +5988,10 @@ fn aiur_fn_31( if (__v_206 != __v_207) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_207.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_208: G = if unconstrained { Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record) }; - let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) }; - let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) }; - let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) }; + let __v_208: G = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_196)?; Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record)? }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_53, &__v_197)?; Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record)? }; + let __v_210: G = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_198)?; Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record)? }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_199)?; Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record)? }; let __u32_sum: u128 = u128::from(((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8) | (__v_38.as_canonical_u64() << 16) | (__v_39.as_canonical_u64() << 24))) + u128::from(((__v_210.as_canonical_u64() << 0) | (__v_211.as_canonical_u64() << 8) | (__v_208.as_canonical_u64() << 16) | (__v_209.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_212: G = G::from_u8(__u32_bytes[0]); @@ -5966,22 +5999,22 @@ fn aiur_fn_31( let __v_214: G = G::from_u8(__u32_bytes[2]); let __v_215: G = G::from_u8(__u32_bytes[3]); let __v_216: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_212; let __vj = __v_213; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_214; let __vj = __v_215; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_212; let __vj = __v_213; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_214; let __vj = __v_215; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_217: G = (__v_216 * __v_216); if (__v_217 != __v_216) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_216.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_212)?; Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record)? }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_213)?; Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record)? }; let __v_220: G = __b2_out.0; let __v_221: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_214)?; Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record)? }; let __v_222: G = __b2_out.0; let __v_223: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_215)?; Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record)? }; let __v_224: G = __b2_out.0; let __v_225: G = __b2_out.1; let __v_226: G = (__v_220 + __v_223); @@ -5995,8 +6028,8 @@ fn aiur_fn_31( let __v_232: G = G::from_u8(__u32_bytes[2]); let __v_233: G = G::from_u8(__u32_bytes[3]); let __v_234: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_230; let __vj = __v_231; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_232; let __vj = __v_233; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_230; let __vj = __v_231; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_232; let __vj = __v_233; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_235: G = G::from_u64(1); let __v_236: G = (__v_234 - __v_235); let __v_237: G = G::from_u64(2); @@ -6007,10 +6040,10 @@ fn aiur_fn_31( if (__v_240 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_242: G = if unconstrained { Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record) }; - let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) }; - let __v_244: G = if unconstrained { Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record) }; - let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) }; + let __v_242: G = if unconstrained { Bytes2::validate_inputs(&__v_210, &__v_230)?; Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record)? }; + let __v_243: G = if unconstrained { Bytes2::validate_inputs(&__v_211, &__v_231)?; Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record)? }; + let __v_244: G = if unconstrained { Bytes2::validate_inputs(&__v_208, &__v_232)?; Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record)? }; + let __v_245: G = if unconstrained { Bytes2::validate_inputs(&__v_209, &__v_233)?; Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record)? }; let __u32_sum: u128 = u128::from(((__v_212.as_canonical_u64() << 0) | (__v_213.as_canonical_u64() << 8) | (__v_214.as_canonical_u64() << 16) | (__v_215.as_canonical_u64() << 24))) + u128::from(((__v_243.as_canonical_u64() << 0) | (__v_244.as_canonical_u64() << 8) | (__v_245.as_canonical_u64() << 16) | (__v_242.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_246: G = G::from_u8(__u32_bytes[0]); @@ -6018,22 +6051,22 @@ fn aiur_fn_31( let __v_248: G = G::from_u8(__u32_bytes[2]); let __v_249: G = G::from_u8(__u32_bytes[3]); let __v_250: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_246; let __vj = __v_247; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_248; let __vj = __v_249; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_246; let __vj = __v_247; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_248; let __vj = __v_249; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_251: G = (__v_250 * __v_250); if (__v_251 != __v_250) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_226, &__v_246)?; Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record)? }; let __v_252: G = __b2_out.0; let __v_253: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_227, &__v_247)?; Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record)? }; let __v_254: G = __b2_out.0; let __v_255: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_228, &__v_248)?; Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record)? }; let __v_256: G = __b2_out.0; let __v_257: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_229, &__v_249)?; Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record)? }; let __v_258: G = __b2_out.0; let __v_259: G = __b2_out.1; let __v_260: G = (__v_252 + __v_255); @@ -6047,8 +6080,8 @@ fn aiur_fn_31( let __v_266: G = G::from_u8(__u32_bytes[2]); let __v_267: G = G::from_u8(__u32_bytes[3]); let __v_268: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_264; let __vj = __v_265; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_266; let __vj = __v_267; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_264; let __vj = __v_265; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_266; let __vj = __v_267; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_269: G = G::from_u64(1); let __v_270: G = (__v_268 - __v_269); let __v_271: G = G::from_u64(2); @@ -6059,10 +6092,10 @@ fn aiur_fn_31( if (__v_274 != __v_275) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_275.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_276: G = if unconstrained { Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record) }; - let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) }; - let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) }; - let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) }; + let __v_276: G = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_264)?; Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record)? }; + let __v_277: G = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_265)?; Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record)? }; + let __v_278: G = if unconstrained { Bytes2::validate_inputs(&__v_58, &__v_266)?; Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record)? }; + let __v_279: G = if unconstrained { Bytes2::validate_inputs(&__v_59, &__v_267)?; Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record)? }; let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_278.as_canonical_u64() << 0) | (__v_279.as_canonical_u64() << 8) | (__v_276.as_canonical_u64() << 16) | (__v_277.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_280: G = G::from_u8(__u32_bytes[0]); @@ -6070,22 +6103,22 @@ fn aiur_fn_31( let __v_282: G = G::from_u8(__u32_bytes[2]); let __v_283: G = G::from_u8(__u32_bytes[3]); let __v_284: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_280; let __vj = __v_281; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_282; let __vj = __v_283; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_280; let __vj = __v_281; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_282; let __vj = __v_283; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_285: G = (__v_284 * __v_284); if (__v_285 != __v_284) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_284.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_280)?; Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record)? }; let __v_286: G = __b2_out.0; let __v_287: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_281)?; Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record)? }; let __v_288: G = __b2_out.0; let __v_289: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_282)?; Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record)? }; let __v_290: G = __b2_out.0; let __v_291: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_283)?; Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record)? }; let __v_292: G = __b2_out.0; let __v_293: G = __b2_out.1; let __v_294: G = (__v_288 + __v_291); @@ -6099,8 +6132,8 @@ fn aiur_fn_31( let __v_300: G = G::from_u8(__u32_bytes[2]); let __v_301: G = G::from_u8(__u32_bytes[3]); let __v_302: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_298; let __vj = __v_299; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_298; let __vj = __v_299; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_300; let __vj = __v_301; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_303: G = G::from_u64(1); let __v_304: G = (__v_302 - __v_303); let __v_305: G = G::from_u64(2); @@ -6111,10 +6144,10 @@ fn aiur_fn_31( if (__v_308 != __v_309) { return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_310: G = if unconstrained { Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record) }; - let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) }; - let __v_312: G = if unconstrained { Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record) }; - let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) }; + let __v_310: G = if unconstrained { Bytes2::validate_inputs(&__v_278, &__v_298)?; Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record)? }; + let __v_311: G = if unconstrained { Bytes2::validate_inputs(&__v_279, &__v_299)?; Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record)? }; + let __v_312: G = if unconstrained { Bytes2::validate_inputs(&__v_276, &__v_300)?; Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record)? }; + let __v_313: G = if unconstrained { Bytes2::validate_inputs(&__v_277, &__v_301)?; Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record)? }; let __u32_sum: u128 = u128::from(((__v_280.as_canonical_u64() << 0) | (__v_281.as_canonical_u64() << 8) | (__v_282.as_canonical_u64() << 16) | (__v_283.as_canonical_u64() << 24))) + u128::from(((__v_311.as_canonical_u64() << 0) | (__v_312.as_canonical_u64() << 8) | (__v_313.as_canonical_u64() << 16) | (__v_310.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_314: G = G::from_u8(__u32_bytes[0]); @@ -6122,22 +6155,22 @@ fn aiur_fn_31( let __v_316: G = G::from_u8(__u32_bytes[2]); let __v_317: G = G::from_u8(__u32_bytes[3]); let __v_318: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_314; let __vj = __v_315; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_316; let __vj = __v_317; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_314; let __vj = __v_315; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_316; let __vj = __v_317; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_319: G = (__v_318 * __v_318); if (__v_319 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_319.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_294, &__v_314)?; Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record)? }; let __v_320: G = __b2_out.0; let __v_321: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_295, &__v_315)?; Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record)? }; let __v_322: G = __b2_out.0; let __v_323: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_296, &__v_316)?; Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record)? }; let __v_324: G = __b2_out.0; let __v_325: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_297, &__v_317)?; Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record)? }; let __v_326: G = __b2_out.0; let __v_327: G = __b2_out.1; let __v_328: G = (__v_320 + __v_323); @@ -6151,8 +6184,8 @@ fn aiur_fn_31( let __v_334: G = G::from_u8(__u32_bytes[2]); let __v_335: G = G::from_u8(__u32_bytes[3]); let __v_336: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_334; let __vj = __v_335; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_332; let __vj = __v_333; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_334; let __vj = __v_335; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_337: G = G::from_u64(1); let __v_338: G = (__v_336 - __v_337); let __v_339: G = G::from_u64(2); @@ -6163,10 +6196,10 @@ fn aiur_fn_31( if (__v_342 != __v_343) { return Err(ExecError::AssertEqMismatch { lhs: __v_342.as_canonical_u64(), rhs: __v_343.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_344: G = if unconstrained { Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record) }; - let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) }; - let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) }; - let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) }; + let __v_344: G = if unconstrained { Bytes2::validate_inputs(&__v_60, &__v_332)?; Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record)? }; + let __v_345: G = if unconstrained { Bytes2::validate_inputs(&__v_61, &__v_333)?; Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record)? }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_62, &__v_334)?; Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record)? }; + let __v_347: G = if unconstrained { Bytes2::validate_inputs(&__v_63, &__v_335)?; Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record)? }; let __u32_sum: u128 = u128::from(((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8) | (__v_46.as_canonical_u64() << 16) | (__v_47.as_canonical_u64() << 24))) + u128::from(((__v_346.as_canonical_u64() << 0) | (__v_347.as_canonical_u64() << 8) | (__v_344.as_canonical_u64() << 16) | (__v_345.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); @@ -6174,22 +6207,22 @@ fn aiur_fn_31( let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_348; let __vj = __v_349; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_350; let __vj = __v_351; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_353: G = (__v_352 * __v_352); if (__v_353 != __v_352) { return Err(ExecError::AssertEqMismatch { lhs: __v_353.as_canonical_u64(), rhs: __v_352.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_348)?; Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record)? }; let __v_354: G = __b2_out.0; let __v_355: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_349)?; Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record)? }; let __v_356: G = __b2_out.0; let __v_357: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_350)?; Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record)? }; let __v_358: G = __b2_out.0; let __v_359: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_351)?; Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record)? }; let __v_360: G = __b2_out.0; let __v_361: G = __b2_out.1; let __v_362: G = (__v_356 + __v_359); @@ -6203,8 +6236,8 @@ fn aiur_fn_31( let __v_368: G = G::from_u8(__u32_bytes[2]); let __v_369: G = G::from_u8(__u32_bytes[3]); let __v_370: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_366; let __vj = __v_367; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_368; let __vj = __v_369; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_366; let __vj = __v_367; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_368; let __vj = __v_369; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_371: G = G::from_u64(1); let __v_372: G = (__v_370 - __v_371); let __v_373: G = G::from_u64(2); @@ -6215,10 +6248,10 @@ fn aiur_fn_31( if (__v_376 != __v_377) { return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_377.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_378: G = if unconstrained { Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record) }; - let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) }; - let __v_380: G = if unconstrained { Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record) }; - let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) }; + let __v_378: G = if unconstrained { Bytes2::validate_inputs(&__v_346, &__v_366)?; Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record)? }; + let __v_379: G = if unconstrained { Bytes2::validate_inputs(&__v_347, &__v_367)?; Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record)? }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_344, &__v_368)?; Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record)? }; + let __v_381: G = if unconstrained { Bytes2::validate_inputs(&__v_345, &__v_369)?; Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record)? }; let __u32_sum: u128 = u128::from(((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8) | (__v_350.as_canonical_u64() << 16) | (__v_351.as_canonical_u64() << 24))) + u128::from(((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8) | (__v_381.as_canonical_u64() << 16) | (__v_378.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_382: G = G::from_u8(__u32_bytes[0]); @@ -6226,22 +6259,22 @@ fn aiur_fn_31( let __v_384: G = G::from_u8(__u32_bytes[2]); let __v_385: G = G::from_u8(__u32_bytes[3]); let __v_386: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_384; let __vj = __v_385; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_382; let __vj = __v_383; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_384; let __vj = __v_385; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_387: G = (__v_386 * __v_386); if (__v_387 != __v_386) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_386.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_362, &__v_382)?; Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record)? }; let __v_388: G = __b2_out.0; let __v_389: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_363, &__v_383)?; Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record)? }; let __v_390: G = __b2_out.0; let __v_391: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_364, &__v_384)?; Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record)? }; let __v_392: G = __b2_out.0; let __v_393: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_365, &__v_385)?; Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record)? }; let __v_394: G = __b2_out.0; let __v_395: G = __b2_out.1; let __v_396: G = (__v_388 + __v_391); @@ -6255,8 +6288,8 @@ fn aiur_fn_31( let __v_402: G = G::from_u8(__u32_bytes[2]); let __v_403: G = G::from_u8(__u32_bytes[3]); let __v_404: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_400; let __vj = __v_401; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_402; let __vj = __v_403; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_400; let __vj = __v_401; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_402; let __vj = __v_403; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_405: G = G::from_u64(1); let __v_406: G = (__v_404 - __v_405); let __v_407: G = G::from_u64(2); @@ -6267,10 +6300,10 @@ fn aiur_fn_31( if (__v_410 != __v_411) { return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_412: G = if unconstrained { Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record) }; - let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) }; - let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) }; - let __v_415: G = if unconstrained { Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record) }; + let __v_412: G = if unconstrained { Bytes2::validate_inputs(&__v_379, &__v_400)?; Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record)? }; + let __v_413: G = if unconstrained { Bytes2::validate_inputs(&__v_380, &__v_401)?; Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record)? }; + let __v_414: G = if unconstrained { Bytes2::validate_inputs(&__v_381, &__v_402)?; Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record)? }; + let __v_415: G = if unconstrained { Bytes2::validate_inputs(&__v_378, &__v_403)?; Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record)? }; let __u32_sum: u128 = u128::from(((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8) | (__v_316.as_canonical_u64() << 16) | (__v_317.as_canonical_u64() << 24))) + u128::from(((__v_414.as_canonical_u64() << 0) | (__v_415.as_canonical_u64() << 8) | (__v_412.as_canonical_u64() << 16) | (__v_413.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_416: G = G::from_u8(__u32_bytes[0]); @@ -6278,22 +6311,22 @@ fn aiur_fn_31( let __v_418: G = G::from_u8(__u32_bytes[2]); let __v_419: G = G::from_u8(__u32_bytes[3]); let __v_420: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_416; let __vj = __v_417; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_418; let __vj = __v_419; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_416; let __vj = __v_417; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_418; let __vj = __v_419; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_421: G = (__v_420 * __v_420); if (__v_421 != __v_420) { return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_420.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_260, &__v_416)?; Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record)? }; let __v_422: G = __b2_out.0; let __v_423: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_261, &__v_417)?; Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record)? }; let __v_424: G = __b2_out.0; let __v_425: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_418)?; Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record)? }; let __v_426: G = __b2_out.0; let __v_427: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_419)?; Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record)? }; let __v_428: G = __b2_out.0; let __v_429: G = __b2_out.1; let __v_430: G = (__v_424 + __v_427); @@ -6307,8 +6340,8 @@ fn aiur_fn_31( let __v_436: G = G::from_u8(__u32_bytes[2]); let __v_437: G = G::from_u8(__u32_bytes[3]); let __v_438: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_434; let __vj = __v_435; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_436; let __vj = __v_437; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_434; let __vj = __v_435; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_436; let __vj = __v_437; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_439: G = G::from_u64(1); let __v_440: G = (__v_438 - __v_439); let __v_441: G = G::from_u64(2); @@ -6319,10 +6352,10 @@ fn aiur_fn_31( if (__v_444 != __v_445) { return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_445.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_446: G = if unconstrained { Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record) }; - let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) }; - let __v_448: G = if unconstrained { Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record) }; - let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) }; + let __v_446: G = if unconstrained { Bytes2::validate_inputs(&__v_414, &__v_434)?; Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record)? }; + let __v_447: G = if unconstrained { Bytes2::validate_inputs(&__v_415, &__v_435)?; Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record)? }; + let __v_448: G = if unconstrained { Bytes2::validate_inputs(&__v_412, &__v_436)?; Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record)? }; + let __v_449: G = if unconstrained { Bytes2::validate_inputs(&__v_413, &__v_437)?; Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record)? }; let __u32_sum: u128 = u128::from(((__v_416.as_canonical_u64() << 0) | (__v_417.as_canonical_u64() << 8) | (__v_418.as_canonical_u64() << 16) | (__v_419.as_canonical_u64() << 24))) + u128::from(((__v_447.as_canonical_u64() << 0) | (__v_448.as_canonical_u64() << 8) | (__v_449.as_canonical_u64() << 16) | (__v_446.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_450: G = G::from_u8(__u32_bytes[0]); @@ -6330,22 +6363,22 @@ fn aiur_fn_31( let __v_452: G = G::from_u8(__u32_bytes[2]); let __v_453: G = G::from_u8(__u32_bytes[3]); let __v_454: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_450; let __vj = __v_451; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_452; let __vj = __v_453; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_450; let __vj = __v_451; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_452; let __vj = __v_453; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_455: G = (__v_454 * __v_454); if (__v_455 != __v_454) { return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_430, &__v_450)?; Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record)? }; let __v_456: G = __b2_out.0; let __v_457: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_431, &__v_451)?; Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record)? }; let __v_458: G = __b2_out.0; let __v_459: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_432, &__v_452)?; Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record)? }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_433, &__v_453)?; Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record)? }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __v_464: G = (__v_456 + __v_459); @@ -6359,8 +6392,8 @@ fn aiur_fn_31( let __v_470: G = G::from_u8(__u32_bytes[2]); let __v_471: G = G::from_u8(__u32_bytes[3]); let __v_472: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_468; let __vj = __v_469; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_470; let __vj = __v_471; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_468; let __vj = __v_469; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_470; let __vj = __v_471; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_473: G = G::from_u64(1); let __v_474: G = (__v_472 - __v_473); let __v_475: G = G::from_u64(2); @@ -6371,10 +6404,10 @@ fn aiur_fn_31( if (__v_478 != __v_479) { return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_480: G = if unconstrained { Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record) }; - let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) }; - let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) }; - let __v_483: G = if unconstrained { Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record) }; + let __v_480: G = if unconstrained { Bytes2::validate_inputs(&__v_175, &__v_468)?; Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record)? }; + let __v_481: G = if unconstrained { Bytes2::validate_inputs(&__v_176, &__v_469)?; Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record)? }; + let __v_482: G = if unconstrained { Bytes2::validate_inputs(&__v_177, &__v_470)?; Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record)? }; + let __v_483: G = if unconstrained { Bytes2::validate_inputs(&__v_174, &__v_471)?; Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record)? }; let __u32_sum: u128 = u128::from(((__v_382.as_canonical_u64() << 0) | (__v_383.as_canonical_u64() << 8) | (__v_384.as_canonical_u64() << 16) | (__v_385.as_canonical_u64() << 24))) + u128::from(((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8) | (__v_480.as_canonical_u64() << 16) | (__v_481.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_484: G = G::from_u8(__u32_bytes[0]); @@ -6382,22 +6415,22 @@ fn aiur_fn_31( let __v_486: G = G::from_u8(__u32_bytes[2]); let __v_487: G = G::from_u8(__u32_bytes[3]); let __v_488: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_484; let __vj = __v_485; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_484; let __vj = __v_485; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_486; let __vj = __v_487; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_489: G = (__v_488 * __v_488); if (__v_489 != __v_488) { return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_328, &__v_484)?; Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record)? }; let __v_490: G = __b2_out.0; let __v_491: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_329, &__v_485)?; Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record)? }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_330, &__v_486)?; Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record)? }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_331, &__v_487)?; Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record)? }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __v_498: G = (__v_492 + __v_495); @@ -6411,8 +6444,8 @@ fn aiur_fn_31( let __v_504: G = G::from_u8(__u32_bytes[2]); let __v_505: G = G::from_u8(__u32_bytes[3]); let __v_506: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_502; let __vj = __v_503; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_502; let __vj = __v_503; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_504; let __vj = __v_505; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_507: G = G::from_u64(1); let __v_508: G = (__v_506 - __v_507); let __v_509: G = G::from_u64(2); @@ -6423,10 +6456,10 @@ fn aiur_fn_31( if (__v_512 != __v_513) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_514: G = if unconstrained { Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record) }; - let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) }; - let __v_516: G = if unconstrained { Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record) }; - let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) }; + let __v_514: G = if unconstrained { Bytes2::validate_inputs(&__v_482, &__v_502)?; Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record)? }; + let __v_515: G = if unconstrained { Bytes2::validate_inputs(&__v_483, &__v_503)?; Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record)? }; + let __v_516: G = if unconstrained { Bytes2::validate_inputs(&__v_480, &__v_504)?; Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record)? }; + let __v_517: G = if unconstrained { Bytes2::validate_inputs(&__v_481, &__v_505)?; Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record)? }; let __u32_sum: u128 = u128::from(((__v_484.as_canonical_u64() << 0) | (__v_485.as_canonical_u64() << 8) | (__v_486.as_canonical_u64() << 16) | (__v_487.as_canonical_u64() << 24))) + u128::from(((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8) | (__v_517.as_canonical_u64() << 16) | (__v_514.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_518: G = G::from_u8(__u32_bytes[0]); @@ -6434,22 +6467,22 @@ fn aiur_fn_31( let __v_520: G = G::from_u8(__u32_bytes[2]); let __v_521: G = G::from_u8(__u32_bytes[3]); let __v_522: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_520; let __vj = __v_521; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_518; let __vj = __v_519; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_520; let __vj = __v_521; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_523: G = (__v_522 * __v_522); if (__v_523 != __v_522) { return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_498, &__v_518)?; Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record)? }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_499, &__v_519)?; Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record)? }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_500, &__v_520)?; Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record)? }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_501, &__v_521)?; Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record)? }; let __v_530: G = __b2_out.0; let __v_531: G = __b2_out.1; let __v_532: G = (__v_524 + __v_527); @@ -6463,8 +6496,8 @@ fn aiur_fn_31( let __v_538: G = G::from_u8(__u32_bytes[2]); let __v_539: G = G::from_u8(__u32_bytes[3]); let __v_540: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_538; let __vj = __v_539; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_536; let __vj = __v_537; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_538; let __vj = __v_539; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_541: G = G::from_u64(1); let __v_542: G = (__v_540 - __v_541); let __v_543: G = G::from_u64(2); @@ -6475,10 +6508,10 @@ fn aiur_fn_31( if (__v_546 != __v_547) { return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_547.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_548: G = if unconstrained { Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record) }; - let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) }; - let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) }; - let __v_551: G = if unconstrained { Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record) }; + let __v_548: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_536)?; Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record)? }; + let __v_549: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_537)?; Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record)? }; + let __v_550: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_538)?; Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record)? }; + let __v_551: G = if unconstrained { Bytes2::validate_inputs(&__v_242, &__v_539)?; Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record)? }; let __u32_sum: u128 = u128::from(((__v_178.as_canonical_u64() << 0) | (__v_179.as_canonical_u64() << 8) | (__v_180.as_canonical_u64() << 16) | (__v_181.as_canonical_u64() << 24))) + u128::from(((__v_550.as_canonical_u64() << 0) | (__v_551.as_canonical_u64() << 8) | (__v_548.as_canonical_u64() << 16) | (__v_549.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_552: G = G::from_u8(__u32_bytes[0]); @@ -6486,22 +6519,22 @@ fn aiur_fn_31( let __v_554: G = G::from_u8(__u32_bytes[2]); let __v_555: G = G::from_u8(__u32_bytes[3]); let __v_556: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_552; let __vj = __v_553; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_554; let __vj = __v_555; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_552; let __vj = __v_553; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_554; let __vj = __v_555; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_557: G = (__v_556 * __v_556); if (__v_557 != __v_556) { return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_396, &__v_552)?; Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record)? }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_553)?; Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record)? }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_398, &__v_554)?; Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record)? }; let __v_562: G = __b2_out.0; let __v_563: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_399, &__v_555)?; Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record)? }; let __v_564: G = __b2_out.0; let __v_565: G = __b2_out.1; let __v_566: G = (__v_560 + __v_563); @@ -6515,8 +6548,8 @@ fn aiur_fn_31( let __v_572: G = G::from_u8(__u32_bytes[2]); let __v_573: G = G::from_u8(__u32_bytes[3]); let __v_574: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_570; let __vj = __v_571; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_572; let __vj = __v_573; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_570; let __vj = __v_571; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_572; let __vj = __v_573; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_575: G = G::from_u64(1); let __v_576: G = (__v_574 - __v_575); let __v_577: G = G::from_u64(2); @@ -6527,10 +6560,10 @@ fn aiur_fn_31( if (__v_580 != __v_581) { return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_581.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_582: G = if unconstrained { Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record) }; - let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) }; - let __v_584: G = if unconstrained { Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record) }; - let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) }; + let __v_582: G = if unconstrained { Bytes2::validate_inputs(&__v_550, &__v_570)?; Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record)? }; + let __v_583: G = if unconstrained { Bytes2::validate_inputs(&__v_551, &__v_571)?; Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record)? }; + let __v_584: G = if unconstrained { Bytes2::validate_inputs(&__v_548, &__v_572)?; Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record)? }; + let __v_585: G = if unconstrained { Bytes2::validate_inputs(&__v_549, &__v_573)?; Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record)? }; let __u32_sum: u128 = u128::from(((__v_552.as_canonical_u64() << 0) | (__v_553.as_canonical_u64() << 8) | (__v_554.as_canonical_u64() << 16) | (__v_555.as_canonical_u64() << 24))) + u128::from(((__v_583.as_canonical_u64() << 0) | (__v_584.as_canonical_u64() << 8) | (__v_585.as_canonical_u64() << 16) | (__v_582.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_586: G = G::from_u8(__u32_bytes[0]); @@ -6538,22 +6571,22 @@ fn aiur_fn_31( let __v_588: G = G::from_u8(__u32_bytes[2]); let __v_589: G = G::from_u8(__u32_bytes[3]); let __v_590: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_586; let __vj = __v_587; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_588; let __vj = __v_589; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_586; let __vj = __v_587; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_588; let __vj = __v_589; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_591: G = (__v_590 * __v_590); if (__v_591 != __v_590) { return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_590.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_566, &__v_586)?; Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record)? }; let __v_592: G = __b2_out.0; let __v_593: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_567, &__v_587)?; Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record)? }; let __v_594: G = __b2_out.0; let __v_595: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_568, &__v_588)?; Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record)? }; let __v_596: G = __b2_out.0; let __v_597: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_569, &__v_589)?; Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record)? }; let __v_598: G = __b2_out.0; let __v_599: G = __b2_out.1; let __v_600: G = (__v_592 + __v_595); @@ -6567,8 +6600,8 @@ fn aiur_fn_31( let __v_606: G = G::from_u8(__u32_bytes[2]); let __v_607: G = G::from_u8(__u32_bytes[3]); let __v_608: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_604; let __vj = __v_605; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_606; let __vj = __v_607; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_604; let __vj = __v_605; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_606; let __vj = __v_607; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_609: G = G::from_u64(1); let __v_610: G = (__v_608 - __v_609); let __v_611: G = G::from_u64(2); @@ -6579,10 +6612,10 @@ fn aiur_fn_31( if (__v_614 != __v_615) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_615.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_616: G = if unconstrained { Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record) }; - let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) }; - let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) }; - let __v_619: G = if unconstrained { Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record) }; + let __v_616: G = if unconstrained { Bytes2::validate_inputs(&__v_311, &__v_604)?; Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record)? }; + let __v_617: G = if unconstrained { Bytes2::validate_inputs(&__v_312, &__v_605)?; Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record)? }; + let __v_618: G = if unconstrained { Bytes2::validate_inputs(&__v_313, &__v_606)?; Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record)? }; + let __v_619: G = if unconstrained { Bytes2::validate_inputs(&__v_310, &__v_607)?; Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record)? }; let __u32_sum: u128 = u128::from(((__v_246.as_canonical_u64() << 0) | (__v_247.as_canonical_u64() << 8) | (__v_248.as_canonical_u64() << 16) | (__v_249.as_canonical_u64() << 24))) + u128::from(((__v_618.as_canonical_u64() << 0) | (__v_619.as_canonical_u64() << 8) | (__v_616.as_canonical_u64() << 16) | (__v_617.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_620: G = G::from_u8(__u32_bytes[0]); @@ -6590,22 +6623,22 @@ fn aiur_fn_31( let __v_622: G = G::from_u8(__u32_bytes[2]); let __v_623: G = G::from_u8(__u32_bytes[3]); let __v_624: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_620; let __vj = __v_621; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_622; let __vj = __v_623; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_620; let __vj = __v_621; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_622; let __vj = __v_623; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_625: G = (__v_624 * __v_624); if (__v_625 != __v_624) { return Err(ExecError::AssertEqMismatch { lhs: __v_625.as_canonical_u64(), rhs: __v_624.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_192, &__v_620)?; Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record)? }; let __v_626: G = __b2_out.0; let __v_627: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_193, &__v_621)?; Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record)? }; let __v_628: G = __b2_out.0; let __v_629: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_194, &__v_622)?; Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record)? }; let __v_630: G = __b2_out.0; let __v_631: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_195, &__v_623)?; Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record)? }; let __v_632: G = __b2_out.0; let __v_633: G = __b2_out.1; let __v_634: G = (__v_628 + __v_631); @@ -6619,8 +6652,8 @@ fn aiur_fn_31( let __v_640: G = G::from_u8(__u32_bytes[2]); let __v_641: G = G::from_u8(__u32_bytes[3]); let __v_642: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_638; let __vj = __v_639; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_640; let __vj = __v_641; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_638; let __vj = __v_639; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_640; let __vj = __v_641; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_643: G = G::from_u64(1); let __v_644: G = (__v_642 - __v_643); let __v_645: G = G::from_u64(2); @@ -6631,10 +6664,10 @@ fn aiur_fn_31( if (__v_648 != __v_649) { return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_650: G = if unconstrained { Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record) }; - let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) }; - let __v_652: G = if unconstrained { Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record) }; - let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) }; + let __v_650: G = if unconstrained { Bytes2::validate_inputs(&__v_618, &__v_638)?; Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record)? }; + let __v_651: G = if unconstrained { Bytes2::validate_inputs(&__v_619, &__v_639)?; Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record)? }; + let __v_652: G = if unconstrained { Bytes2::validate_inputs(&__v_616, &__v_640)?; Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record)? }; + let __v_653: G = if unconstrained { Bytes2::validate_inputs(&__v_617, &__v_641)?; Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record)? }; let __u32_sum: u128 = u128::from(((__v_620.as_canonical_u64() << 0) | (__v_621.as_canonical_u64() << 8) | (__v_622.as_canonical_u64() << 16) | (__v_623.as_canonical_u64() << 24))) + u128::from(((__v_651.as_canonical_u64() << 0) | (__v_652.as_canonical_u64() << 8) | (__v_653.as_canonical_u64() << 16) | (__v_650.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_654: G = G::from_u8(__u32_bytes[0]); @@ -6642,22 +6675,22 @@ fn aiur_fn_31( let __v_656: G = G::from_u8(__u32_bytes[2]); let __v_657: G = G::from_u8(__u32_bytes[3]); let __v_658: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_654; let __vj = __v_655; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_656; let __vj = __v_657; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_654; let __vj = __v_655; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_656; let __vj = __v_657; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_659: G = (__v_658 * __v_658); if (__v_659 != __v_658) { return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_658.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_634, &__v_654)?; Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record)? }; let __v_660: G = __b2_out.0; let __v_661: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_635, &__v_655)?; Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record)? }; let __v_662: G = __b2_out.0; let __v_663: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_636, &__v_656)?; Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record)? }; let __v_664: G = __b2_out.0; let __v_665: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_637, &__v_657)?; Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record)? }; let __v_666: G = __b2_out.0; let __v_667: G = __b2_out.1; let __v_668: G = (__v_660 + __v_663); @@ -6665,7 +6698,7 @@ fn aiur_fn_31( let __v_670: G = (__v_664 + __v_667); let __v_671: G = (__v_666 + __v_661); let __ret: [G; OUT_31] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; - record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[31].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -6674,118 +6707,119 @@ const INPUT_SIZE_32: usize = 106; const IN_32: usize = 106; const OUT_32: usize = 32; fn aiur_fn_32( - inp: [G; IN_32], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; + record.checkpoint(32); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); @@ -6809,7 +6843,7 @@ fn aiur_fn_32( 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_33] = { let __args: [G; IN_33] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -6843,7 +6877,7 @@ fn aiur_fn_32( let __v_159: G = __r_arr[30]; let __v_160: G = __r_arr[31]; let __ret: [G; OUT_32] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[32].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -6852,177 +6886,178 @@ const INPUT_SIZE_33: usize = 129; const IN_33: usize = 129; const OUT_33: usize = 32; fn aiur_fn_33( - inp: [G; IN_33], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; - let __v_106: G = inp[106]; - let __v_107: G = inp[107]; - let __v_108: G = inp[108]; - let __v_109: G = inp[109]; - let __v_110: G = inp[110]; - let __v_111: G = inp[111]; - let __v_112: G = inp[112]; - let __v_113: G = inp[113]; - let __v_114: G = inp[114]; - let __v_115: G = inp[115]; - let __v_116: G = inp[116]; - let __v_117: G = inp[117]; - let __v_118: G = inp[118]; - let __v_119: G = inp[119]; - let __v_120: G = inp[120]; - let __v_121: G = inp[121]; - let __v_122: G = inp[122]; - let __v_123: G = inp[123]; - let __v_124: G = inp[124]; - let __v_125: G = inp[125]; - let __v_126: G = inp[126]; - let __v_127: G = inp[127]; - let __v_128: G = inp[128]; + record.checkpoint(33); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; + let __v_106: G = inp.values()[106]; + let __v_107: G = inp.values()[107]; + let __v_108: G = inp.values()[108]; + let __v_109: G = inp.values()[109]; + let __v_110: G = inp.values()[110]; + let __v_111: G = inp.values()[111]; + let __v_112: G = inp.values()[112]; + let __v_113: G = inp.values()[113]; + let __v_114: G = inp.values()[114]; + let __v_115: G = inp.values()[115]; + let __v_116: G = inp.values()[116]; + let __v_117: G = inp.values()[117]; + let __v_118: G = inp.values()[118]; + let __v_119: G = inp.values()[119]; + let __v_120: G = inp.values()[120]; + let __v_121: G = inp.values()[121]; + let __v_122: G = inp.values()[122]; + let __v_123: G = inp.values()[123]; + let __v_124: G = inp.values()[124]; + let __v_125: G = inp.values()[125]; + let __v_126: G = inp.values()[126]; + let __v_127: G = inp.values()[127]; + let __v_128: G = inp.values()[128]; match __v_0.as_canonical_u64() { 7u64 => { - let __v_129: G = if unconstrained { Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record) }; - let __v_130: G = if unconstrained { Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record) }; - let __v_131: G = if unconstrained { Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record) }; - let __v_132: G = if unconstrained { Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record) }; - let __v_133: G = if unconstrained { Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record) }; - let __v_134: G = if unconstrained { Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record) }; - let __v_135: G = if unconstrained { Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record) }; - let __v_136: G = if unconstrained { Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record) }; - let __v_137: G = if unconstrained { Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record) }; - let __v_138: G = if unconstrained { Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record) }; - let __v_139: G = if unconstrained { Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record) }; - let __v_140: G = if unconstrained { Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record) }; - let __v_141: G = if unconstrained { Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record) }; - let __v_144: G = if unconstrained { Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record) }; - let __v_145: G = if unconstrained { Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record) }; - let __v_146: G = if unconstrained { Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record) }; - let __v_147: G = if unconstrained { Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record) }; - let __v_148: G = if unconstrained { Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record) }; - let __v_149: G = if unconstrained { Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record) }; - let __v_150: G = if unconstrained { Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record) }; - let __v_151: G = if unconstrained { Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record) }; - let __v_152: G = if unconstrained { Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record) }; - let __v_153: G = if unconstrained { Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record) }; - let __v_154: G = if unconstrained { Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record) }; - let __v_155: G = if unconstrained { Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record) }; - let __v_156: G = if unconstrained { Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record) }; - let __v_157: G = if unconstrained { Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record) }; - let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) }; - let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) }; - let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) }; + let __v_129: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_33)?; Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record)? }; + let __v_130: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_34)?; Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record)? }; + let __v_131: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_35)?; Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record)? }; + let __v_132: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_36)?; Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record)? }; + let __v_133: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_37)?; Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record)? }; + let __v_134: G = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_38)?; Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record)? }; + let __v_135: G = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_39)?; Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record)? }; + let __v_136: G = if unconstrained { Bytes2::validate_inputs(&__v_8, &__v_40)?; Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record)? }; + let __v_137: G = if unconstrained { Bytes2::validate_inputs(&__v_9, &__v_41)?; Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record)? }; + let __v_138: G = if unconstrained { Bytes2::validate_inputs(&__v_10, &__v_42)?; Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record)? }; + let __v_139: G = if unconstrained { Bytes2::validate_inputs(&__v_11, &__v_43)?; Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record)? }; + let __v_140: G = if unconstrained { Bytes2::validate_inputs(&__v_12, &__v_44)?; Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record)? }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_13, &__v_45)?; Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_14, &__v_46)?; Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_15, &__v_47)?; Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record)? }; + let __v_144: G = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_48)?; Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record)? }; + let __v_145: G = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_49)?; Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record)? }; + let __v_146: G = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_50)?; Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record)? }; + let __v_147: G = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_51)?; Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record)? }; + let __v_148: G = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_52)?; Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record)? }; + let __v_149: G = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_53)?; Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record)? }; + let __v_150: G = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_54)?; Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record)? }; + let __v_151: G = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_55)?; Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record)? }; + let __v_152: G = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_56)?; Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record)? }; + let __v_153: G = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_57)?; Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record)? }; + let __v_154: G = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_58)?; Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record)? }; + let __v_155: G = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_59)?; Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record)? }; + let __v_156: G = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_60)?; Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record)? }; + let __v_157: G = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_61)?; Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record)? }; + let __v_158: G = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_62)?; Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record)? }; + let __v_159: G = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_63)?; Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record)? }; + let __v_160: G = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_64)?; Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record)? }; let __ret: [G; OUT_33] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[33].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -7033,8 +7068,8 @@ fn aiur_fn_33( let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_129; let __vj = __v_130; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_131; let __vj = __v_132; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); @@ -7045,10 +7080,10 @@ fn aiur_fn_33( if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) }; - let __v_144: G = if unconstrained { Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record) }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_49, &__v_129)?; Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_50, &__v_130)?; Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_51, &__v_131)?; Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record)? }; + let __v_144: G = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_132)?; Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record)? }; let __u32_sum: u128 = u128::from(((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8) | (__v_35.as_canonical_u64() << 16) | (__v_36.as_canonical_u64() << 24))) + u128::from(((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8) | (__v_141.as_canonical_u64() << 16) | (__v_142.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); @@ -7056,22 +7091,22 @@ fn aiur_fn_33( let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_145; let __vj = __v_146; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_147; let __vj = __v_148; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_145)?; Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record)? }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_146)?; Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record)? }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_147)?; Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record)? }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_148)?; Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record)? }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); @@ -7085,8 +7120,8 @@ fn aiur_fn_33( let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_163; let __vj = __v_164; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_165; let __vj = __v_166; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_168: G = G::from_u64(1); let __v_169: G = (__v_167 - __v_168); let __v_170: G = G::from_u64(2); @@ -7097,10 +7132,10 @@ fn aiur_fn_33( if (__v_173 != __v_174) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_174.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) }; - let __v_176: G = if unconstrained { Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record) }; - let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) }; - let __v_178: G = if unconstrained { Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record) }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_143, &__v_163)?; Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record)? }; + let __v_176: G = if unconstrained { Bytes2::validate_inputs(&__v_144, &__v_164)?; Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record)? }; + let __v_177: G = if unconstrained { Bytes2::validate_inputs(&__v_141, &__v_165)?; Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record)? }; + let __v_178: G = if unconstrained { Bytes2::validate_inputs(&__v_142, &__v_166)?; Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record)? }; let __u32_sum: u128 = u128::from(((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8) | (__v_147.as_canonical_u64() << 16) | (__v_148.as_canonical_u64() << 24))) + u128::from(((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8) | (__v_178.as_canonical_u64() << 16) | (__v_175.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_179: G = G::from_u8(__u32_bytes[0]); @@ -7108,22 +7143,22 @@ fn aiur_fn_33( let __v_181: G = G::from_u8(__u32_bytes[2]); let __v_182: G = G::from_u8(__u32_bytes[3]); let __v_183: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_179; let __vj = __v_180; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_181; let __vj = __v_182; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_179; let __vj = __v_180; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_181; let __vj = __v_182; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_184: G = (__v_183 * __v_183); if (__v_184 != __v_183) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_159, &__v_179)?; Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record)? }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_160, &__v_180)?; Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record)? }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_161, &__v_181)?; Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record)? }; let __v_189: G = __b2_out.0; let __v_190: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_162, &__v_182)?; Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record)? }; let __v_191: G = __b2_out.0; let __v_192: G = __b2_out.1; let __v_193: G = (__v_185 + __v_188); @@ -7137,8 +7172,8 @@ fn aiur_fn_33( let __v_199: G = G::from_u8(__u32_bytes[2]); let __v_200: G = G::from_u8(__u32_bytes[3]); let __v_201: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_197; let __vj = __v_198; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_199; let __vj = __v_200; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_197; let __vj = __v_198; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_199; let __vj = __v_200; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_202: G = G::from_u64(1); let __v_203: G = (__v_201 - __v_202); let __v_204: G = G::from_u64(2); @@ -7149,10 +7184,10 @@ fn aiur_fn_33( if (__v_207 != __v_208) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_208.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) }; - let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) }; - let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) }; - let __v_212: G = if unconstrained { Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record) }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_53, &__v_197)?; Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record)? }; + let __v_210: G = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_198)?; Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record)? }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_199)?; Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record)? }; + let __v_212: G = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_200)?; Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record)? }; let __u32_sum: u128 = u128::from(((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8) | (__v_39.as_canonical_u64() << 16) | (__v_40.as_canonical_u64() << 24))) + u128::from(((__v_211.as_canonical_u64() << 0) | (__v_212.as_canonical_u64() << 8) | (__v_209.as_canonical_u64() << 16) | (__v_210.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_213: G = G::from_u8(__u32_bytes[0]); @@ -7160,22 +7195,22 @@ fn aiur_fn_33( let __v_215: G = G::from_u8(__u32_bytes[2]); let __v_216: G = G::from_u8(__u32_bytes[3]); let __v_217: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_213; let __vj = __v_214; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_215; let __vj = __v_216; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_213; let __vj = __v_214; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_215; let __vj = __v_216; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_218: G = (__v_217 * __v_217); if (__v_218 != __v_217) { return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_217.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_213)?; Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record)? }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_214)?; Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record)? }; let __v_221: G = __b2_out.0; let __v_222: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_215)?; Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record)? }; let __v_223: G = __b2_out.0; let __v_224: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_216)?; Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record)? }; let __v_225: G = __b2_out.0; let __v_226: G = __b2_out.1; let __v_227: G = (__v_221 + __v_224); @@ -7189,8 +7224,8 @@ fn aiur_fn_33( let __v_233: G = G::from_u8(__u32_bytes[2]); let __v_234: G = G::from_u8(__u32_bytes[3]); let __v_235: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_231; let __vj = __v_232; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_233; let __vj = __v_234; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_236: G = G::from_u64(1); let __v_237: G = (__v_235 - __v_236); let __v_238: G = G::from_u64(2); @@ -7201,10 +7236,10 @@ fn aiur_fn_33( if (__v_241 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) }; - let __v_244: G = if unconstrained { Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record) }; - let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) }; - let __v_246: G = if unconstrained { Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record) }; + let __v_243: G = if unconstrained { Bytes2::validate_inputs(&__v_211, &__v_231)?; Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record)? }; + let __v_244: G = if unconstrained { Bytes2::validate_inputs(&__v_212, &__v_232)?; Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record)? }; + let __v_245: G = if unconstrained { Bytes2::validate_inputs(&__v_209, &__v_233)?; Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record)? }; + let __v_246: G = if unconstrained { Bytes2::validate_inputs(&__v_210, &__v_234)?; Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record)? }; let __u32_sum: u128 = u128::from(((__v_213.as_canonical_u64() << 0) | (__v_214.as_canonical_u64() << 8) | (__v_215.as_canonical_u64() << 16) | (__v_216.as_canonical_u64() << 24))) + u128::from(((__v_244.as_canonical_u64() << 0) | (__v_245.as_canonical_u64() << 8) | (__v_246.as_canonical_u64() << 16) | (__v_243.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_247: G = G::from_u8(__u32_bytes[0]); @@ -7212,22 +7247,22 @@ fn aiur_fn_33( let __v_249: G = G::from_u8(__u32_bytes[2]); let __v_250: G = G::from_u8(__u32_bytes[3]); let __v_251: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_247; let __vj = __v_248; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_249; let __vj = __v_250; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_247; let __vj = __v_248; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_249; let __vj = __v_250; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_252: G = (__v_251 * __v_251); if (__v_252 != __v_251) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_227, &__v_247)?; Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record)? }; let __v_253: G = __b2_out.0; let __v_254: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_228, &__v_248)?; Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record)? }; let __v_255: G = __b2_out.0; let __v_256: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_229, &__v_249)?; Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record)? }; let __v_257: G = __b2_out.0; let __v_258: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_230, &__v_250)?; Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record)? }; let __v_259: G = __b2_out.0; let __v_260: G = __b2_out.1; let __v_261: G = (__v_253 + __v_256); @@ -7241,8 +7276,8 @@ fn aiur_fn_33( let __v_267: G = G::from_u8(__u32_bytes[2]); let __v_268: G = G::from_u8(__u32_bytes[3]); let __v_269: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_265; let __vj = __v_266; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_267; let __vj = __v_268; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_270: G = G::from_u64(1); let __v_271: G = (__v_269 - __v_270); let __v_272: G = G::from_u64(2); @@ -7253,10 +7288,10 @@ fn aiur_fn_33( if (__v_275 != __v_276) { return Err(ExecError::AssertEqMismatch { lhs: __v_275.as_canonical_u64(), rhs: __v_276.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) }; - let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) }; - let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) }; - let __v_280: G = if unconstrained { Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record) }; + let __v_277: G = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_265)?; Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record)? }; + let __v_278: G = if unconstrained { Bytes2::validate_inputs(&__v_58, &__v_266)?; Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record)? }; + let __v_279: G = if unconstrained { Bytes2::validate_inputs(&__v_59, &__v_267)?; Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record)? }; + let __v_280: G = if unconstrained { Bytes2::validate_inputs(&__v_60, &__v_268)?; Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record)? }; let __u32_sum: u128 = u128::from(((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8) | (__v_43.as_canonical_u64() << 16) | (__v_44.as_canonical_u64() << 24))) + u128::from(((__v_279.as_canonical_u64() << 0) | (__v_280.as_canonical_u64() << 8) | (__v_277.as_canonical_u64() << 16) | (__v_278.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_281: G = G::from_u8(__u32_bytes[0]); @@ -7264,22 +7299,22 @@ fn aiur_fn_33( let __v_283: G = G::from_u8(__u32_bytes[2]); let __v_284: G = G::from_u8(__u32_bytes[3]); let __v_285: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_281; let __vj = __v_282; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_283; let __vj = __v_284; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_281; let __vj = __v_282; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_283; let __vj = __v_284; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_286: G = (__v_285 * __v_285); if (__v_286 != __v_285) { return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_285.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_281)?; Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record)? }; let __v_287: G = __b2_out.0; let __v_288: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_282)?; Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record)? }; let __v_289: G = __b2_out.0; let __v_290: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_283)?; Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record)? }; let __v_291: G = __b2_out.0; let __v_292: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_284)?; Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record)? }; let __v_293: G = __b2_out.0; let __v_294: G = __b2_out.1; let __v_295: G = (__v_289 + __v_292); @@ -7293,8 +7328,8 @@ fn aiur_fn_33( let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_299; let __vj = __v_300; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_301; let __vj = __v_302; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_304: G = G::from_u64(1); let __v_305: G = (__v_303 - __v_304); let __v_306: G = G::from_u64(2); @@ -7305,10 +7340,10 @@ fn aiur_fn_33( if (__v_309 != __v_310) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_310.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) }; - let __v_312: G = if unconstrained { Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record) }; - let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) }; - let __v_314: G = if unconstrained { Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record) }; + let __v_311: G = if unconstrained { Bytes2::validate_inputs(&__v_279, &__v_299)?; Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record)? }; + let __v_312: G = if unconstrained { Bytes2::validate_inputs(&__v_280, &__v_300)?; Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record)? }; + let __v_313: G = if unconstrained { Bytes2::validate_inputs(&__v_277, &__v_301)?; Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record)? }; + let __v_314: G = if unconstrained { Bytes2::validate_inputs(&__v_278, &__v_302)?; Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record)? }; let __u32_sum: u128 = u128::from(((__v_281.as_canonical_u64() << 0) | (__v_282.as_canonical_u64() << 8) | (__v_283.as_canonical_u64() << 16) | (__v_284.as_canonical_u64() << 24))) + u128::from(((__v_312.as_canonical_u64() << 0) | (__v_313.as_canonical_u64() << 8) | (__v_314.as_canonical_u64() << 16) | (__v_311.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_315: G = G::from_u8(__u32_bytes[0]); @@ -7316,22 +7351,22 @@ fn aiur_fn_33( let __v_317: G = G::from_u8(__u32_bytes[2]); let __v_318: G = G::from_u8(__u32_bytes[3]); let __v_319: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_315; let __vj = __v_316; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_315; let __vj = __v_316; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_317; let __vj = __v_318; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_320: G = (__v_319 * __v_319); if (__v_320 != __v_319) { return Err(ExecError::AssertEqMismatch { lhs: __v_320.as_canonical_u64(), rhs: __v_319.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_295, &__v_315)?; Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record)? }; let __v_321: G = __b2_out.0; let __v_322: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_296, &__v_316)?; Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record)? }; let __v_323: G = __b2_out.0; let __v_324: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_297, &__v_317)?; Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record)? }; let __v_325: G = __b2_out.0; let __v_326: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_298, &__v_318)?; Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record)? }; let __v_327: G = __b2_out.0; let __v_328: G = __b2_out.1; let __v_329: G = (__v_321 + __v_324); @@ -7345,8 +7380,8 @@ fn aiur_fn_33( let __v_335: G = G::from_u8(__u32_bytes[2]); let __v_336: G = G::from_u8(__u32_bytes[3]); let __v_337: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_335; let __vj = __v_336; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_333; let __vj = __v_334; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_335; let __vj = __v_336; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_338: G = G::from_u64(1); let __v_339: G = (__v_337 - __v_338); let __v_340: G = G::from_u64(2); @@ -7357,10 +7392,10 @@ fn aiur_fn_33( if (__v_343 != __v_344) { return Err(ExecError::AssertEqMismatch { lhs: __v_343.as_canonical_u64(), rhs: __v_344.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) }; - let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) }; - let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) }; - let __v_348: G = if unconstrained { Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record) }; + let __v_345: G = if unconstrained { Bytes2::validate_inputs(&__v_61, &__v_333)?; Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record)? }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_62, &__v_334)?; Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record)? }; + let __v_347: G = if unconstrained { Bytes2::validate_inputs(&__v_63, &__v_335)?; Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record)? }; + let __v_348: G = if unconstrained { Bytes2::validate_inputs(&__v_64, &__v_336)?; Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record)? }; let __u32_sum: u128 = u128::from(((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8) | (__v_47.as_canonical_u64() << 16) | (__v_48.as_canonical_u64() << 24))) + u128::from(((__v_347.as_canonical_u64() << 0) | (__v_348.as_canonical_u64() << 8) | (__v_345.as_canonical_u64() << 16) | (__v_346.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); @@ -7368,22 +7403,22 @@ fn aiur_fn_33( let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_349; let __vj = __v_350; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_351; let __vj = __v_352; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_354: G = (__v_353 * __v_353); if (__v_354 != __v_353) { return Err(ExecError::AssertEqMismatch { lhs: __v_354.as_canonical_u64(), rhs: __v_353.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_349)?; Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record)? }; let __v_355: G = __b2_out.0; let __v_356: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_350)?; Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record)? }; let __v_357: G = __b2_out.0; let __v_358: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_351)?; Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record)? }; let __v_359: G = __b2_out.0; let __v_360: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_352)?; Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record)? }; let __v_361: G = __b2_out.0; let __v_362: G = __b2_out.1; let __v_363: G = (__v_357 + __v_360); @@ -7397,8 +7432,8 @@ fn aiur_fn_33( let __v_369: G = G::from_u8(__u32_bytes[2]); let __v_370: G = G::from_u8(__u32_bytes[3]); let __v_371: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_367; let __vj = __v_368; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_369; let __vj = __v_370; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_367; let __vj = __v_368; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_369; let __vj = __v_370; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_372: G = G::from_u64(1); let __v_373: G = (__v_371 - __v_372); let __v_374: G = G::from_u64(2); @@ -7409,10 +7444,10 @@ fn aiur_fn_33( if (__v_377 != __v_378) { return Err(ExecError::AssertEqMismatch { lhs: __v_377.as_canonical_u64(), rhs: __v_378.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) }; - let __v_380: G = if unconstrained { Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record) }; - let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) }; - let __v_382: G = if unconstrained { Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record) }; + let __v_379: G = if unconstrained { Bytes2::validate_inputs(&__v_347, &__v_367)?; Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record)? }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_348, &__v_368)?; Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record)? }; + let __v_381: G = if unconstrained { Bytes2::validate_inputs(&__v_345, &__v_369)?; Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record)? }; + let __v_382: G = if unconstrained { Bytes2::validate_inputs(&__v_346, &__v_370)?; Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record)? }; let __u32_sum: u128 = u128::from(((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8) | (__v_351.as_canonical_u64() << 16) | (__v_352.as_canonical_u64() << 24))) + u128::from(((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8) | (__v_382.as_canonical_u64() << 16) | (__v_379.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_383: G = G::from_u8(__u32_bytes[0]); @@ -7420,22 +7455,22 @@ fn aiur_fn_33( let __v_385: G = G::from_u8(__u32_bytes[2]); let __v_386: G = G::from_u8(__u32_bytes[3]); let __v_387: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_383; let __vj = __v_384; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_385; let __vj = __v_386; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_383; let __vj = __v_384; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_385; let __vj = __v_386; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_388: G = (__v_387 * __v_387); if (__v_388 != __v_387) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_363, &__v_383)?; Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record)? }; let __v_389: G = __b2_out.0; let __v_390: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_364, &__v_384)?; Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record)? }; let __v_391: G = __b2_out.0; let __v_392: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_365, &__v_385)?; Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record)? }; let __v_393: G = __b2_out.0; let __v_394: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_366, &__v_386)?; Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record)? }; let __v_395: G = __b2_out.0; let __v_396: G = __b2_out.1; let __v_397: G = (__v_389 + __v_392); @@ -7449,8 +7484,8 @@ fn aiur_fn_33( let __v_403: G = G::from_u8(__u32_bytes[2]); let __v_404: G = G::from_u8(__u32_bytes[3]); let __v_405: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_401; let __vj = __v_402; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_403; let __vj = __v_404; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_401; let __vj = __v_402; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_403; let __vj = __v_404; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_406: G = G::from_u64(1); let __v_407: G = (__v_405 - __v_406); let __v_408: G = G::from_u64(2); @@ -7461,10 +7496,10 @@ fn aiur_fn_33( if (__v_411 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) }; - let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) }; - let __v_415: G = if unconstrained { Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record) }; - let __v_416: G = if unconstrained { Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record) }; + let __v_413: G = if unconstrained { Bytes2::validate_inputs(&__v_380, &__v_401)?; Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record)? }; + let __v_414: G = if unconstrained { Bytes2::validate_inputs(&__v_381, &__v_402)?; Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record)? }; + let __v_415: G = if unconstrained { Bytes2::validate_inputs(&__v_382, &__v_403)?; Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record)? }; + let __v_416: G = if unconstrained { Bytes2::validate_inputs(&__v_379, &__v_404)?; Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record)? }; let __u32_sum: u128 = u128::from(((__v_315.as_canonical_u64() << 0) | (__v_316.as_canonical_u64() << 8) | (__v_317.as_canonical_u64() << 16) | (__v_318.as_canonical_u64() << 24))) + u128::from(((__v_415.as_canonical_u64() << 0) | (__v_416.as_canonical_u64() << 8) | (__v_413.as_canonical_u64() << 16) | (__v_414.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_417: G = G::from_u8(__u32_bytes[0]); @@ -7472,22 +7507,22 @@ fn aiur_fn_33( let __v_419: G = G::from_u8(__u32_bytes[2]); let __v_420: G = G::from_u8(__u32_bytes[3]); let __v_421: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_417; let __vj = __v_418; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_419; let __vj = __v_420; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_417; let __vj = __v_418; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_419; let __vj = __v_420; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_422: G = (__v_421 * __v_421); if (__v_422 != __v_421) { return Err(ExecError::AssertEqMismatch { lhs: __v_422.as_canonical_u64(), rhs: __v_421.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_261, &__v_417)?; Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record)? }; let __v_423: G = __b2_out.0; let __v_424: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_418)?; Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record)? }; let __v_425: G = __b2_out.0; let __v_426: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_419)?; Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record)? }; let __v_427: G = __b2_out.0; let __v_428: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_264, &__v_420)?; Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record)? }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __v_431: G = (__v_425 + __v_428); @@ -7501,8 +7536,8 @@ fn aiur_fn_33( let __v_437: G = G::from_u8(__u32_bytes[2]); let __v_438: G = G::from_u8(__u32_bytes[3]); let __v_439: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_435; let __vj = __v_436; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_437; let __vj = __v_438; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_435; let __vj = __v_436; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_437; let __vj = __v_438; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_440: G = G::from_u64(1); let __v_441: G = (__v_439 - __v_440); let __v_442: G = G::from_u64(2); @@ -7513,10 +7548,10 @@ fn aiur_fn_33( if (__v_445 != __v_446) { return Err(ExecError::AssertEqMismatch { lhs: __v_445.as_canonical_u64(), rhs: __v_446.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) }; - let __v_448: G = if unconstrained { Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record) }; - let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) }; - let __v_450: G = if unconstrained { Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record) }; + let __v_447: G = if unconstrained { Bytes2::validate_inputs(&__v_415, &__v_435)?; Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record)? }; + let __v_448: G = if unconstrained { Bytes2::validate_inputs(&__v_416, &__v_436)?; Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record)? }; + let __v_449: G = if unconstrained { Bytes2::validate_inputs(&__v_413, &__v_437)?; Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record)? }; + let __v_450: G = if unconstrained { Bytes2::validate_inputs(&__v_414, &__v_438)?; Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record)? }; let __u32_sum: u128 = u128::from(((__v_417.as_canonical_u64() << 0) | (__v_418.as_canonical_u64() << 8) | (__v_419.as_canonical_u64() << 16) | (__v_420.as_canonical_u64() << 24))) + u128::from(((__v_448.as_canonical_u64() << 0) | (__v_449.as_canonical_u64() << 8) | (__v_450.as_canonical_u64() << 16) | (__v_447.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_451: G = G::from_u8(__u32_bytes[0]); @@ -7524,22 +7559,22 @@ fn aiur_fn_33( let __v_453: G = G::from_u8(__u32_bytes[2]); let __v_454: G = G::from_u8(__u32_bytes[3]); let __v_455: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_451; let __vj = __v_452; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_453; let __vj = __v_454; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_451; let __vj = __v_452; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_453; let __vj = __v_454; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_456: G = (__v_455 * __v_455); if (__v_456 != __v_455) { return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_431, &__v_451)?; Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record)? }; let __v_457: G = __b2_out.0; let __v_458: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_432, &__v_452)?; Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record)? }; let __v_459: G = __b2_out.0; let __v_460: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_433, &__v_453)?; Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record)? }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_434, &__v_454)?; Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record)? }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __v_465: G = (__v_457 + __v_460); @@ -7553,8 +7588,8 @@ fn aiur_fn_33( let __v_471: G = G::from_u8(__u32_bytes[2]); let __v_472: G = G::from_u8(__u32_bytes[3]); let __v_473: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_469; let __vj = __v_470; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_471; let __vj = __v_472; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_469; let __vj = __v_470; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_471; let __vj = __v_472; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_474: G = G::from_u64(1); let __v_475: G = (__v_473 - __v_474); let __v_476: G = G::from_u64(2); @@ -7565,10 +7600,10 @@ fn aiur_fn_33( if (__v_479 != __v_480) { return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) }; - let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) }; - let __v_483: G = if unconstrained { Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record) }; - let __v_484: G = if unconstrained { Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record) }; + let __v_481: G = if unconstrained { Bytes2::validate_inputs(&__v_176, &__v_469)?; Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record)? }; + let __v_482: G = if unconstrained { Bytes2::validate_inputs(&__v_177, &__v_470)?; Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record)? }; + let __v_483: G = if unconstrained { Bytes2::validate_inputs(&__v_178, &__v_471)?; Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record)? }; + let __v_484: G = if unconstrained { Bytes2::validate_inputs(&__v_175, &__v_472)?; Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record)? }; let __u32_sum: u128 = u128::from(((__v_383.as_canonical_u64() << 0) | (__v_384.as_canonical_u64() << 8) | (__v_385.as_canonical_u64() << 16) | (__v_386.as_canonical_u64() << 24))) + u128::from(((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8) | (__v_481.as_canonical_u64() << 16) | (__v_482.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); @@ -7576,22 +7611,22 @@ fn aiur_fn_33( let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_485; let __vj = __v_486; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_487; let __vj = __v_488; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_329, &__v_485)?; Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record)? }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_330, &__v_486)?; Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record)? }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_331, &__v_487)?; Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record)? }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_332, &__v_488)?; Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record)? }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_493 + __v_496); @@ -7605,8 +7640,8 @@ fn aiur_fn_33( let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_503; let __vj = __v_504; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_505; let __vj = __v_506; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_508: G = G::from_u64(1); let __v_509: G = (__v_507 - __v_508); let __v_510: G = G::from_u64(2); @@ -7617,10 +7652,10 @@ fn aiur_fn_33( if (__v_513 != __v_514) { return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) }; - let __v_516: G = if unconstrained { Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record) }; - let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) }; - let __v_518: G = if unconstrained { Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record) }; + let __v_515: G = if unconstrained { Bytes2::validate_inputs(&__v_483, &__v_503)?; Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record)? }; + let __v_516: G = if unconstrained { Bytes2::validate_inputs(&__v_484, &__v_504)?; Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record)? }; + let __v_517: G = if unconstrained { Bytes2::validate_inputs(&__v_481, &__v_505)?; Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record)? }; + let __v_518: G = if unconstrained { Bytes2::validate_inputs(&__v_482, &__v_506)?; Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record)? }; let __u32_sum: u128 = u128::from(((__v_485.as_canonical_u64() << 0) | (__v_486.as_canonical_u64() << 8) | (__v_487.as_canonical_u64() << 16) | (__v_488.as_canonical_u64() << 24))) + u128::from(((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8) | (__v_518.as_canonical_u64() << 16) | (__v_515.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_519: G = G::from_u8(__u32_bytes[0]); @@ -7628,22 +7663,22 @@ fn aiur_fn_33( let __v_521: G = G::from_u8(__u32_bytes[2]); let __v_522: G = G::from_u8(__u32_bytes[3]); let __v_523: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_521; let __vj = __v_522; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_519; let __vj = __v_520; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_521; let __vj = __v_522; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_524: G = (__v_523 * __v_523); if (__v_524 != __v_523) { return Err(ExecError::AssertEqMismatch { lhs: __v_524.as_canonical_u64(), rhs: __v_523.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_499, &__v_519)?; Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record)? }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_500, &__v_520)?; Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record)? }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_501, &__v_521)?; Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record)? }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_502, &__v_522)?; Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record)? }; let __v_531: G = __b2_out.0; let __v_532: G = __b2_out.1; let __v_533: G = (__v_525 + __v_528); @@ -7657,8 +7692,8 @@ fn aiur_fn_33( let __v_539: G = G::from_u8(__u32_bytes[2]); let __v_540: G = G::from_u8(__u32_bytes[3]); let __v_541: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_539; let __vj = __v_540; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_537; let __vj = __v_538; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_539; let __vj = __v_540; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_542: G = G::from_u64(1); let __v_543: G = (__v_541 - __v_542); let __v_544: G = G::from_u64(2); @@ -7669,10 +7704,10 @@ fn aiur_fn_33( if (__v_547 != __v_548) { return Err(ExecError::AssertEqMismatch { lhs: __v_547.as_canonical_u64(), rhs: __v_548.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) }; - let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) }; - let __v_551: G = if unconstrained { Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record) }; - let __v_552: G = if unconstrained { Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record) }; + let __v_549: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_537)?; Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record)? }; + let __v_550: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_538)?; Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record)? }; + let __v_551: G = if unconstrained { Bytes2::validate_inputs(&__v_246, &__v_539)?; Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record)? }; + let __v_552: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_540)?; Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record)? }; let __u32_sum: u128 = u128::from(((__v_179.as_canonical_u64() << 0) | (__v_180.as_canonical_u64() << 8) | (__v_181.as_canonical_u64() << 16) | (__v_182.as_canonical_u64() << 24))) + u128::from(((__v_551.as_canonical_u64() << 0) | (__v_552.as_canonical_u64() << 8) | (__v_549.as_canonical_u64() << 16) | (__v_550.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_553: G = G::from_u8(__u32_bytes[0]); @@ -7680,22 +7715,22 @@ fn aiur_fn_33( let __v_555: G = G::from_u8(__u32_bytes[2]); let __v_556: G = G::from_u8(__u32_bytes[3]); let __v_557: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_553; let __vj = __v_554; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_555; let __vj = __v_556; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_553; let __vj = __v_554; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_555; let __vj = __v_556; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_558: G = (__v_557 * __v_557); if (__v_558 != __v_557) { return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_553)?; Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record)? }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_398, &__v_554)?; Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record)? }; let __v_561: G = __b2_out.0; let __v_562: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_399, &__v_555)?; Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record)? }; let __v_563: G = __b2_out.0; let __v_564: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_400, &__v_556)?; Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record)? }; let __v_565: G = __b2_out.0; let __v_566: G = __b2_out.1; let __v_567: G = (__v_561 + __v_564); @@ -7709,8 +7744,8 @@ fn aiur_fn_33( let __v_573: G = G::from_u8(__u32_bytes[2]); let __v_574: G = G::from_u8(__u32_bytes[3]); let __v_575: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_571; let __vj = __v_572; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_573; let __vj = __v_574; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_571; let __vj = __v_572; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_573; let __vj = __v_574; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_576: G = G::from_u64(1); let __v_577: G = (__v_575 - __v_576); let __v_578: G = G::from_u64(2); @@ -7721,10 +7756,10 @@ fn aiur_fn_33( if (__v_581 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_581.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) }; - let __v_584: G = if unconstrained { Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record) }; - let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) }; - let __v_586: G = if unconstrained { Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record) }; + let __v_583: G = if unconstrained { Bytes2::validate_inputs(&__v_551, &__v_571)?; Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record)? }; + let __v_584: G = if unconstrained { Bytes2::validate_inputs(&__v_552, &__v_572)?; Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record)? }; + let __v_585: G = if unconstrained { Bytes2::validate_inputs(&__v_549, &__v_573)?; Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record)? }; + let __v_586: G = if unconstrained { Bytes2::validate_inputs(&__v_550, &__v_574)?; Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record)? }; let __u32_sum: u128 = u128::from(((__v_553.as_canonical_u64() << 0) | (__v_554.as_canonical_u64() << 8) | (__v_555.as_canonical_u64() << 16) | (__v_556.as_canonical_u64() << 24))) + u128::from(((__v_584.as_canonical_u64() << 0) | (__v_585.as_canonical_u64() << 8) | (__v_586.as_canonical_u64() << 16) | (__v_583.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_587: G = G::from_u8(__u32_bytes[0]); @@ -7732,22 +7767,22 @@ fn aiur_fn_33( let __v_589: G = G::from_u8(__u32_bytes[2]); let __v_590: G = G::from_u8(__u32_bytes[3]); let __v_591: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_587; let __vj = __v_588; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_589; let __vj = __v_590; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_587; let __vj = __v_588; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_589; let __vj = __v_590; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_592: G = (__v_591 * __v_591); if (__v_592 != __v_591) { return Err(ExecError::AssertEqMismatch { lhs: __v_592.as_canonical_u64(), rhs: __v_591.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_567, &__v_587)?; Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record)? }; let __v_593: G = __b2_out.0; let __v_594: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_568, &__v_588)?; Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record)? }; let __v_595: G = __b2_out.0; let __v_596: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_569, &__v_589)?; Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record)? }; let __v_597: G = __b2_out.0; let __v_598: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_570, &__v_590)?; Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record)? }; let __v_599: G = __b2_out.0; let __v_600: G = __b2_out.1; let __v_601: G = (__v_593 + __v_596); @@ -7761,8 +7796,8 @@ fn aiur_fn_33( let __v_607: G = G::from_u8(__u32_bytes[2]); let __v_608: G = G::from_u8(__u32_bytes[3]); let __v_609: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_605; let __vj = __v_606; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_607; let __vj = __v_608; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_605; let __vj = __v_606; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_607; let __vj = __v_608; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_610: G = G::from_u64(1); let __v_611: G = (__v_609 - __v_610); let __v_612: G = G::from_u64(2); @@ -7773,10 +7808,10 @@ fn aiur_fn_33( if (__v_615 != __v_616) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_616.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) }; - let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) }; - let __v_619: G = if unconstrained { Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record) }; - let __v_620: G = if unconstrained { Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record) }; + let __v_617: G = if unconstrained { Bytes2::validate_inputs(&__v_312, &__v_605)?; Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record)? }; + let __v_618: G = if unconstrained { Bytes2::validate_inputs(&__v_313, &__v_606)?; Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record)? }; + let __v_619: G = if unconstrained { Bytes2::validate_inputs(&__v_314, &__v_607)?; Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record)? }; + let __v_620: G = if unconstrained { Bytes2::validate_inputs(&__v_311, &__v_608)?; Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record)? }; let __u32_sum: u128 = u128::from(((__v_247.as_canonical_u64() << 0) | (__v_248.as_canonical_u64() << 8) | (__v_249.as_canonical_u64() << 16) | (__v_250.as_canonical_u64() << 24))) + u128::from(((__v_619.as_canonical_u64() << 0) | (__v_620.as_canonical_u64() << 8) | (__v_617.as_canonical_u64() << 16) | (__v_618.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_621: G = G::from_u8(__u32_bytes[0]); @@ -7784,22 +7819,22 @@ fn aiur_fn_33( let __v_623: G = G::from_u8(__u32_bytes[2]); let __v_624: G = G::from_u8(__u32_bytes[3]); let __v_625: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_621; let __vj = __v_622; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_623; let __vj = __v_624; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_621; let __vj = __v_622; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_623; let __vj = __v_624; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_626: G = (__v_625 * __v_625); if (__v_626 != __v_625) { return Err(ExecError::AssertEqMismatch { lhs: __v_626.as_canonical_u64(), rhs: __v_625.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_193, &__v_621)?; Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record)? }; let __v_627: G = __b2_out.0; let __v_628: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_194, &__v_622)?; Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record)? }; let __v_629: G = __b2_out.0; let __v_630: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_195, &__v_623)?; Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record)? }; let __v_631: G = __b2_out.0; let __v_632: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_196, &__v_624)?; Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record)? }; let __v_633: G = __b2_out.0; let __v_634: G = __b2_out.1; let __v_635: G = (__v_629 + __v_632); @@ -7813,8 +7848,8 @@ fn aiur_fn_33( let __v_641: G = G::from_u8(__u32_bytes[2]); let __v_642: G = G::from_u8(__u32_bytes[3]); let __v_643: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_639; let __vj = __v_640; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_641; let __vj = __v_642; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_639; let __vj = __v_640; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_641; let __vj = __v_642; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_644: G = G::from_u64(1); let __v_645: G = (__v_643 - __v_644); let __v_646: G = G::from_u64(2); @@ -7825,10 +7860,10 @@ fn aiur_fn_33( if (__v_649 != __v_650) { return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) }; - let __v_652: G = if unconstrained { Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record) }; - let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) }; - let __v_654: G = if unconstrained { Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record) }; + let __v_651: G = if unconstrained { Bytes2::validate_inputs(&__v_619, &__v_639)?; Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record)? }; + let __v_652: G = if unconstrained { Bytes2::validate_inputs(&__v_620, &__v_640)?; Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record)? }; + let __v_653: G = if unconstrained { Bytes2::validate_inputs(&__v_617, &__v_641)?; Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record)? }; + let __v_654: G = if unconstrained { Bytes2::validate_inputs(&__v_618, &__v_642)?; Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record)? }; let __u32_sum: u128 = u128::from(((__v_621.as_canonical_u64() << 0) | (__v_622.as_canonical_u64() << 8) | (__v_623.as_canonical_u64() << 16) | (__v_624.as_canonical_u64() << 24))) + u128::from(((__v_652.as_canonical_u64() << 0) | (__v_653.as_canonical_u64() << 8) | (__v_654.as_canonical_u64() << 16) | (__v_651.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_655: G = G::from_u8(__u32_bytes[0]); @@ -7836,22 +7871,22 @@ fn aiur_fn_33( let __v_657: G = G::from_u8(__u32_bytes[2]); let __v_658: G = G::from_u8(__u32_bytes[3]); let __v_659: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_655; let __vj = __v_656; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_657; let __vj = __v_658; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_655; let __vj = __v_656; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_657; let __vj = __v_658; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_660: G = (__v_659 * __v_659); if (__v_660 != __v_659) { return Err(ExecError::AssertEqMismatch { lhs: __v_660.as_canonical_u64(), rhs: __v_659.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_635, &__v_655)?; Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record)? }; let __v_661: G = __b2_out.0; let __v_662: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_636, &__v_656)?; Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record)? }; let __v_663: G = __b2_out.0; let __v_664: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_637, &__v_657)?; Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record)? }; let __v_665: G = __b2_out.0; let __v_666: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_638, &__v_658)?; Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record)? }; let __v_667: G = __b2_out.0; let __v_668: G = __b2_out.1; let __v_669: G = (__v_661 + __v_664); @@ -7860,7 +7895,7 @@ fn aiur_fn_33( 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_33] = { let __args: [G; IN_33] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[33].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i); } let __ret: [G; OUT_33] = unsafe { *(record.function_queries[33].output_at(__i).as_ptr() as *const [G; OUT_33]) }; __ret }, _ => aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_33] = { let __args: [G; IN_33] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[33].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[33].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[33].bump_multiplicity(__i)?; } record.function_queries[33].output_at(__i).to_array::() }, _ => aiur_fn_33(__key, 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]; @@ -7894,7 +7929,7 @@ fn aiur_fn_33( let __v_705: G = __r_arr[30]; let __v_706: G = __r_arr[31]; let __ret: [G; OUT_33] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; - record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[33].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -7905,50 +7940,51 @@ const INPUT_SIZE_34: usize = 19; const IN_34: usize = 19; const OUT_34: usize = 1; fn aiur_fn_34( - inp: [G; IN_34], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(34); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; match __v_0.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_20]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_20]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[764].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i)?; } record.function_queries[764].output_at(__i).to_array::() }, _ => aiur_fn_764(__key, 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]; @@ -7958,18 +7994,18 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_30]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[764].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i)?; } record.function_queries[764].output_at(__i).to_array::() }, _ => aiur_fn_764(__key, 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]; @@ -7979,18 +8015,18 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(3); - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_9, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_30]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8010,34 +8046,34 @@ fn aiur_fn_34( let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; let __v_37: G = G::from_u64(4); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_37, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_40]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_19: G = G::from_u64(5); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_20]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_19: G = G::from_u64(6); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_20]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8047,16 +8083,16 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(7); - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[45].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i)?; } record.function_queries[45].output_at(__i).to_array::() }, _ => aiur_fn_45(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_29]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[43].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i)?; } record.function_queries[43].output_at(__i).to_array::() }, _ => aiur_fn_43(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8066,16 +8102,16 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(8); - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_29]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -8085,16 +8121,16 @@ fn aiur_fn_34( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = G::from_u64(9); - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_29]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8113,7 +8149,7 @@ fn aiur_fn_34( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8132,7 +8168,7 @@ fn aiur_fn_34( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; @@ -8152,24 +8188,24 @@ fn aiur_fn_34( let __v_71: G = __loaded[16]; let __v_72: G = __loaded[17]; let __v_73: G = G::from_u64(10); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_77]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { let __v_19: G = G::from_u64(11); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_34] = [__v_20]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8183,26 +8219,27 @@ const INPUT_SIZE_35: usize = 10; const IN_35: usize = 10; const OUT_35: usize = 1; fn aiur_fn_35( - inp: [G; IN_35], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(35); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_8.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_35] = [__v_9]; - record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[35].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8210,11 +8247,11 @@ fn aiur_fn_35( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_8 - __v_12); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10, __v_13, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_0, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_35] = [__v_15]; - record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[35].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8225,33 +8262,34 @@ const INPUT_SIZE_36: usize = 9; const IN_36: usize = 9; const OUT_36: usize = 1; fn aiur_fn_36( - inp: [G; IN_36], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + record.checkpoint(36); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(128); - let __v_11: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record) }; + let __v_11: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_10)?; Bytes2::less_than(&__v_0, &__v_10) } else { bytes2_less_than_value(__v_0, __v_10, record)? }; match __v_9.as_canonical_u64() { 1u64 => { match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_13]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8260,11 +8298,11 @@ fn aiur_fn_36( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_18]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8275,11 +8313,11 @@ fn aiur_fn_36( let __v_14: G = (__v_9 - __v_13); let __v_15: G = (__v_12 + __v_14); let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_9, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_15, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_18]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8290,26 +8328,27 @@ const INPUT_SIZE_37: usize = 10; const IN_37: usize = 10; const OUT_37: usize = 1; fn aiur_fn_37( - inp: [G; IN_37], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + record.checkpoint(37); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(32); - let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; + let __v_12: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_11)?; Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record)? }; match __v_10.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { @@ -8318,9 +8357,9 @@ fn aiur_fn_37( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_37] = [__v_17]; - record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[37].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8332,11 +8371,11 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_37] = [__v_22]; - record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[37].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8350,11 +8389,11 @@ fn aiur_fn_37( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_37] = [__v_22]; - record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[37].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8365,26 +8404,27 @@ const INPUT_SIZE_38: usize = 10; const IN_38: usize = 10; const OUT_38: usize = 1; fn aiur_fn_38( - inp: [G; IN_38], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + record.checkpoint(38); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); - let __v_12: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record) }; + let __v_12: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_11)?; Bytes2::less_than(&__v_1, &__v_11) } else { bytes2_less_than_value(__v_1, __v_11, record)? }; match __v_10.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { @@ -8393,9 +8433,9 @@ fn aiur_fn_38( let __v_14: G = (__v_0 * __v_13); let __v_15: G = (__v_14 + __v_1); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_17]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8407,11 +8447,11 @@ fn aiur_fn_38( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_22]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8425,11 +8465,11 @@ fn aiur_fn_38( let __v_18: G = (__v_15 + __v_17); let __v_19: G = (__v_14 + __v_18); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_19, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_22]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8440,15 +8480,16 @@ const INPUT_SIZE_39: usize = 2; const IN_39: usize = 2; const OUT_39: usize = 1; fn aiur_fn_39( - inp: [G; IN_39], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_39], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(39); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -8462,16 +8503,16 @@ fn aiur_fn_39( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_39] = [__v_1]; - record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[39].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_39] = [__v_13]; - record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[39].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8485,45 +8526,46 @@ const INPUT_SIZE_40: usize = 2; const IN_40: usize = 2; const OUT_40: usize = 1; fn aiur_fn_40( - inp: [G; IN_40], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(40); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_4]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_4]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_4]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(3); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_4]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8537,32 +8579,33 @@ const INPUT_SIZE_41: usize = 3; const IN_41: usize = 3; const OUT_41: usize = 1; fn aiur_fn_41( - inp: [G; IN_41], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(41); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(4); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8575,17 +8618,17 @@ fn aiur_fn_41( 0u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(5); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8598,17 +8641,17 @@ fn aiur_fn_41( 0u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(2); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(6); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8621,17 +8664,17 @@ fn aiur_fn_41( 0u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(3); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(7); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_41] = [__v_5]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8650,33 +8693,34 @@ const INPUT_SIZE_42: usize = 18; const IN_42: usize = 18; const OUT_42: usize = 8; fn aiur_fn_42( - inp: [G; IN_42], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; + record.checkpoint(42); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; match __v_0.as_canonical_u64() { 7u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8695,7 +8739,7 @@ fn aiur_fn_42( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8704,7 +8748,7 @@ fn aiur_fn_42( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -8714,7 +8758,7 @@ fn aiur_fn_42( let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[42].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8727,7 +8771,7 @@ fn aiur_fn_42( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[42].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8738,33 +8782,34 @@ const INPUT_SIZE_43: usize = 18; const IN_43: usize = 18; const OUT_43: usize = 8; fn aiur_fn_43( - inp: [G; IN_43], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __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]; + record.checkpoint(43); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8783,7 +8828,7 @@ fn aiur_fn_43( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[43].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i)?; } record.function_queries[43].output_at(__i).to_array::() }, _ => aiur_fn_43(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8792,7 +8837,7 @@ fn aiur_fn_43( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -8802,7 +8847,7 @@ fn aiur_fn_43( let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[43].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8815,7 +8860,7 @@ fn aiur_fn_43( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[43].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8826,33 +8871,34 @@ const INPUT_SIZE_44: usize = 18; const IN_44: usize = 18; const OUT_44: usize = 8; fn aiur_fn_44( - inp: [G; IN_44], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(44); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -8871,7 +8917,7 @@ fn aiur_fn_44( let __v_33: G = __loaded[15]; let __v_34: G = __loaded[16]; let __v_35: G = __loaded[17]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -8880,7 +8926,7 @@ fn aiur_fn_44( let __v_41: G = __r_arr[5]; let __v_42: G = __r_arr[6]; let __v_43: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -8890,7 +8936,7 @@ fn aiur_fn_44( let __v_50: G = __r_arr[6]; let __v_51: G = __r_arr[7]; let __ret: [G; OUT_44] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; - record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[44].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8903,7 +8949,7 @@ fn aiur_fn_44( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[44].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8914,34 +8960,35 @@ const INPUT_SIZE_45: usize = 19; const IN_45: usize = 19; const OUT_45: usize = 1; fn aiur_fn_45( - inp: [G; IN_45], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(45); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; match __v_0.as_canonical_u64() { 7u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -8960,7 +9007,7 @@ fn aiur_fn_45( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -8979,19 +9026,19 @@ fn aiur_fn_45( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[45].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i)?; } record.function_queries[45].output_at(__i).to_array::() }, _ => aiur_fn_45(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_56]; - record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[45].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_45] = [__v_19]; - record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[45].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9002,34 +9049,35 @@ const INPUT_SIZE_46: usize = 19; const IN_46: usize = 19; const OUT_46: usize = 1; fn aiur_fn_46( - inp: [G; IN_46], + inp: QueryKey, 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]; - let __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]; + record.checkpoint(46); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; match __v_0.as_canonical_u64() { 8u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9048,7 +9096,7 @@ fn aiur_fn_46( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -9067,21 +9115,21 @@ fn aiur_fn_46( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[40].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i)?; } record.function_queries[40].output_at(__i).to_array::() }, _ => aiur_fn_40(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_46] = [__v_57]; - record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[46].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_46] = [__v_19]; - record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[46].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9092,34 +9140,35 @@ const INPUT_SIZE_47: usize = 19; const IN_47: usize = 19; const OUT_47: usize = 1; fn aiur_fn_47( - inp: [G; IN_47], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(47); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; match __v_0.as_canonical_u64() { 9u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9138,7 +9187,7 @@ fn aiur_fn_47( let __v_34: G = __loaded[15]; let __v_35: G = __loaded[16]; let __v_36: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; @@ -9157,21 +9206,21 @@ fn aiur_fn_47( let __v_52: G = __loaded[15]; let __v_53: G = __loaded[16]; let __v_54: G = __loaded[17]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_2, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_2, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[41].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[41].bump_multiplicity(__i)?; } record.function_queries[41].output_at(__i).to_array::() }, _ => aiur_fn_41(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __ret: [G; OUT_47] = [__v_57]; - record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[47].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __ret: [G; OUT_47] = [__v_19]; - record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[47].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9182,15 +9231,16 @@ const INPUT_SIZE_48: usize = 2; const IN_48: usize = 2; const OUT_48: usize = 1; fn aiur_fn_48( - inp: [G; IN_48], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(48); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -9224,71 +9274,71 @@ fn aiur_fn_48( let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_96: G = G::from_u64(0); - let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_48] = [__v_97]; - record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[48].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9297,33 +9347,34 @@ const INPUT_SIZE_49: usize = 2; const IN_49: usize = 2; const OUT_49: usize = 1; fn aiur_fn_49( - inp: [G; IN_49], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(49); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(2); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9336,19 +9387,19 @@ fn aiur_fn_49( 0u64 => { let __v_2: G = G::from_u64(4); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(5); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(6); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9361,19 +9412,19 @@ fn aiur_fn_49( 0u64 => { let __v_2: G = G::from_u64(8); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(9); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_2: G = G::from_u64(10); let __ret: [G; OUT_49] = [__v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9392,24 +9443,25 @@ const INPUT_SIZE_50: usize = 9; const IN_50: usize = 9; const OUT_50: usize = 8; fn aiur_fn_50( - inp: [G; IN_50], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(50); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; match __v_0.as_canonical_u64() { 1u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -9419,7 +9471,7 @@ fn aiur_fn_50( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[50].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i)?; } record.function_queries[50].output_at(__i).to_array::() }, _ => aiur_fn_50(__key, 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]; @@ -9428,7 +9480,7 @@ fn aiur_fn_50( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -9438,7 +9490,7 @@ fn aiur_fn_50( let __v_32: G = __r_arr[6]; let __v_33: G = __r_arr[7]; let __ret: [G; OUT_50] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[50].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9451,7 +9503,7 @@ fn aiur_fn_50( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __ret: [G; OUT_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; - record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[50].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9462,24 +9514,25 @@ const INPUT_SIZE_51: usize = 9; const IN_51: usize = 9; const OUT_51: usize = 9; fn aiur_fn_51( - inp: [G; IN_51], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(51); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; match __v_0.as_canonical_u64() { 1u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -9489,7 +9542,7 @@ fn aiur_fn_51( let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; let __v_17: G = __loaded[8]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, 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]; @@ -9500,12 +9553,12 @@ fn aiur_fn_51( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __ret: [G; OUT_51] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[51].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[51].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9516,33 +9569,34 @@ const INPUT_SIZE_52: usize = 10; const IN_52: usize = 10; const OUT_52: usize = 1; fn aiur_fn_52( - inp: [G; IN_52], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(52); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_0.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_52] = [__v_12]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[50].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i)?; } record.function_queries[50].output_at(__i).to_array::() }, _ => aiur_fn_50(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -9551,7 +9605,7 @@ fn aiur_fn_52( let __v_15: G = __r_arr[5]; let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -9562,16 +9616,16 @@ fn aiur_fn_52( let __v_25: G = __r_arr[7]; let __v_26: G = __r_arr[8]; let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[52].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i)?; } record.function_queries[52].output_at(__i).to_array::() }, _ => aiur_fn_52(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_29]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -9581,7 +9635,7 @@ fn aiur_fn_52( let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9600,18 +9654,18 @@ fn aiur_fn_52( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[52].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i)?; } record.function_queries[52].output_at(__i).to_array::() }, _ => aiur_fn_52(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[52].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i)?; } record.function_queries[52].output_at(__i).to_array::() }, _ => aiur_fn_52(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_39]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -9621,7 +9675,7 @@ fn aiur_fn_52( let __v_16: G = __loaded[6]; let __v_17: G = __loaded[7]; let __v_18: G = __loaded[8]; - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -9640,22 +9694,22 @@ fn aiur_fn_52( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[52].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i)?; } record.function_queries[52].output_at(__i).to_array::() }, _ => aiur_fn_52(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[52].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i)?; } record.function_queries[52].output_at(__i).to_array::() }, _ => aiur_fn_52(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_39]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_52] = [__v_11]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9669,26 +9723,27 @@ const INPUT_SIZE_53: usize = 2; const IN_53: usize = 2; const OUT_53: usize = 1; fn aiur_fn_53( - inp: [G; IN_53], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(53); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_53] = [__v_1]; - record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[53].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -9707,12 +9762,12 @@ fn aiur_fn_53( let __v_20: G = __loaded[15]; let __v_21: G = __loaded[16]; let __v_22: G = __loaded[17]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[53].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i)?; } record.function_queries[53].output_at(__i).to_array::() }, _ => aiur_fn_53(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_53] = [__v_24]; - record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[53].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9726,26 +9781,27 @@ const INPUT_SIZE_54: usize = 2; const IN_54: usize = 2; const OUT_54: usize = 1; fn aiur_fn_54( - inp: [G; IN_54], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(54); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_54] = [__v_1]; - record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[54].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -9755,12 +9811,12 @@ fn aiur_fn_54( let __v_11: G = __loaded[6]; let __v_12: G = __loaded[7]; let __v_13: G = __loaded[8]; - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[54].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i)?; } record.function_queries[54].output_at(__i).to_array::() }, _ => aiur_fn_54(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[52].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i)?; } record.function_queries[52].output_at(__i).to_array::() }, _ => aiur_fn_52(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __ret: [G; OUT_54] = [__v_15]; - record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[54].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9774,31 +9830,32 @@ const INPUT_SIZE_55: usize = 2; const IN_55: usize = 2; const OUT_55: usize = 1; fn aiur_fn_55( - inp: [G; IN_55], + inp: QueryKey, 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]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(55); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_55] = [__v_1]; - record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[55].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_55] = [__v_6]; - record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[55].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9812,28 +9869,29 @@ const INPUT_SIZE_56: usize = 13; const IN_56: usize = 13; const OUT_56: usize = 1; fn aiur_fn_56( - inp: [G; IN_56], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(56); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -9852,7 +9910,7 @@ fn aiur_fn_56( let __v_28: G = __loaded[15]; let __v_29: G = __loaded[16]; let __v_30: G = __loaded[17]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; @@ -9871,18 +9929,18 @@ fn aiur_fn_56( let __v_46: G = __loaded[15]; let __v_47: G = __loaded[16]; let __v_48: G = __loaded[17]; - let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[49].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[49].bump_multiplicity(__i)?; } record.function_queries[49].output_at(__i).to_array::() }, _ => aiur_fn_49(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_49, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_56] = [__v_54]; - record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[56].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9893,25 +9951,26 @@ const INPUT_SIZE_57: usize = 10; const IN_57: usize = 10; const OUT_57: usize = 1; fn aiur_fn_57( - inp: [G; IN_57], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(57); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -9930,12 +9989,12 @@ fn aiur_fn_57( let __v_25: G = __loaded[15]; let __v_26: G = __loaded[16]; let __v_27: G = __loaded[17]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_57] = [__v_29]; - record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[57].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9946,15 +10005,16 @@ const INPUT_SIZE_58: usize = 2; const IN_58: usize = 2; const OUT_58: usize = 1; fn aiur_fn_58( - inp: [G; IN_58], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + record.checkpoint(58); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<11>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -9969,16 +10029,16 @@ fn aiur_fn_58( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_58] = [__v_1]; - record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[58].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[57].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => aiur_fn_57(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[57].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[57].bump_multiplicity(__i)?; } record.function_queries[57].output_at(__i).to_array::() }, _ => aiur_fn_57(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_58] = [__v_14]; - record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[58].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -9992,60 +10052,61 @@ const INPUT_SIZE_59: usize = 45; const IN_59: usize = 45; const OUT_59: usize = 1; fn aiur_fn_59( - inp: [G; IN_59], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; + record.checkpoint(59); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_45: G = __loaded[0]; let __v_46: G = __loaded[1]; let __v_47: G = __loaded[2]; @@ -10067,7 +10128,7 @@ fn aiur_fn_59( let __v_63: G = G::from_u64(2); let __v_64: G = (__v_63 * __v_1); let __v_65: G = (__v_0 + __v_64); - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[776].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i)?; } record.function_queries[776].output_at(__i).to_array::() }, _ => aiur_fn_776(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -10077,25 +10138,25 @@ fn aiur_fn_59( let __v_72: G = __r_arr[6]; let __v_73: G = __r_arr[7]; let __v_74: G = G::from_u64(0); - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_77]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_78]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_80]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_74, __v_65, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_59] = [__v_83]; - record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[59].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10106,26 +10167,27 @@ const INPUT_SIZE_60: usize = 11; const IN_60: usize = 11; const OUT_60: usize = 1; fn aiur_fn_60( - inp: [G; IN_60], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(60); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -10145,13 +10207,13 @@ fn aiur_fn_60( let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_29, __v_0, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_60] = [__v_32]; - record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[60].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10162,26 +10224,27 @@ const INPUT_SIZE_61: usize = 11; const IN_61: usize = 11; const OUT_61: usize = 1; fn aiur_fn_61( - inp: [G; IN_61], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(61); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -10200,14 +10263,14 @@ fn aiur_fn_61( let __v_26: G = __loaded[15]; let __v_27: G = __loaded[16]; let __v_28: G = __loaded[17]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[40].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i)?; } record.function_queries[40].output_at(__i).to_array::() }, _ => aiur_fn_40(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_61] = [__v_31]; - record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[61].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10218,50 +10281,51 @@ const INPUT_SIZE_62: usize = 35; const IN_62: usize = 35; const OUT_62: usize = 1; fn aiur_fn_62( - inp: [G; IN_62], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; + record.checkpoint(62); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -10281,19 +10345,19 @@ fn aiur_fn_62( let __v_51: G = __loaded[16]; let __v_52: G = __loaded[17]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_53, __v_0, __v_58]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_62] = [__v_59]; - record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[62].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10304,15 +10368,16 @@ const INPUT_SIZE_63: usize = 2; const IN_63: usize = 2; const OUT_63: usize = 1; fn aiur_fn_63( - inp: [G; IN_63], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + record.checkpoint(63); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<36>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10352,16 +10417,16 @@ fn aiur_fn_63( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_63] = [__v_1]; - record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[63].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_37, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_37, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[63].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i)?; } record.function_queries[63].output_at(__i).to_array::() }, _ => aiur_fn_63(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[62].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[62].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => aiur_fn_62(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[62].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[62].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[62].bump_multiplicity(__i)?; } record.function_queries[62].output_at(__i).to_array::() }, _ => aiur_fn_62(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __ret: [G; OUT_63] = [__v_39]; - record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[63].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10375,43 +10440,44 @@ const INPUT_SIZE_64: usize = 28; const IN_64: usize = 28; const OUT_64: usize = 1; fn aiur_fn_64( - inp: [G; IN_64], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; + record.checkpoint(64); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; match __v_0.as_canonical_u64() { _ => { - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; @@ -10430,7 +10496,7 @@ fn aiur_fn_64( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[765].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[771].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i)?; } record.function_queries[771].output_at(__i).to_array::() }, _ => aiur_fn_771(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -10440,21 +10506,21 @@ fn aiur_fn_64( let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[63].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i)?; } record.function_queries[63].output_at(__i).to_array::() }, _ => aiur_fn_63(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_54, __v_0, __v_60]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_64] = [__v_61]; - record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[64].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10465,30 +10531,31 @@ const INPUT_SIZE_65: usize = 10; const IN_65: usize = 10; const OUT_65: usize = 1; fn aiur_fn_65( - inp: [G; IN_65], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(65); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_65] = [__v_11]; - record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[65].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10499,40 +10566,41 @@ const INPUT_SIZE_66: usize = 18; const IN_66: usize = 18; const OUT_66: usize = 1; fn aiur_fn_66( - inp: [G; IN_66], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; + record.checkpoint(66); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_66] = [__v_20]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10543,87 +10611,88 @@ const INPUT_SIZE_67: usize = 46; const IN_67: usize = 46; const OUT_67: usize = 1; fn aiur_fn_67( - inp: [G; IN_67], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; + record.checkpoint(67); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; match __v_0.as_canonical_u64() { 0u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[56].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i)?; } record.function_queries[56].output_at(__i).to_array::() }, _ => aiur_fn_56(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_67] = [__v_49]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[64].bump_multiplicity(__i); } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[64].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[64].bump_multiplicity(__i)?; } record.function_queries[64].output_at(__i).to_array::() }, _ => aiur_fn_64(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_67] = [__v_49]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[59].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i)?; } record.function_queries[59].output_at(__i).to_array::() }, _ => aiur_fn_59(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_67] = [__v_49]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10637,15 +10706,16 @@ const INPUT_SIZE_68: usize = 2; const IN_68: usize = 2; const OUT_68: usize = 1; fn aiur_fn_68( - inp: [G; IN_68], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(68); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10696,16 +10766,16 @@ fn aiur_fn_68( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_68] = [__v_1]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_48, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_50]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10719,113 +10789,114 @@ const INPUT_SIZE_69: usize = 46; const IN_69: usize = 46; const OUT_69: usize = 1; fn aiur_fn_69( - inp: [G; IN_69], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; + record.checkpoint(69); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[56].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i)?; } record.function_queries[56].output_at(__i).to_array::() }, _ => aiur_fn_56(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[59].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i)?; } record.function_queries[59].output_at(__i).to_array::() }, _ => aiur_fn_59(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[60].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i)?; } record.function_queries[60].output_at(__i).to_array::() }, _ => aiur_fn_60(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[61].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => aiur_fn_61(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[61].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[61].bump_multiplicity(__i)?; } record.function_queries[61].output_at(__i).to_array::() }, _ => aiur_fn_61(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[66].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i)?; } record.function_queries[66].output_at(__i).to_array::() }, _ => aiur_fn_66(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __ret: [G; OUT_69] = [__v_46]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10839,15 +10910,16 @@ const INPUT_SIZE_70: usize = 2; const IN_70: usize = 2; const OUT_70: usize = 1; fn aiur_fn_70( - inp: [G; IN_70], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; + record.checkpoint(70); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[766].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i)?; } record.function_queries[766].output_at(__i).to_array::() }, _ => aiur_fn_766(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10856,12 +10928,12 @@ fn aiur_fn_70( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[53].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i)?; } record.function_queries[53].output_at(__i).to_array::() }, _ => aiur_fn_53(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_11]; - record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[70].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -10870,15 +10942,16 @@ const INPUT_SIZE_71: usize = 2; const IN_71: usize = 2; const OUT_71: usize = 1; fn aiur_fn_71( - inp: [G; IN_71], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; + record.checkpoint(71); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[766].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i)?; } record.function_queries[766].output_at(__i).to_array::() }, _ => aiur_fn_766(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10887,12 +10960,12 @@ fn aiur_fn_71( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_71] = [__v_11]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -10901,15 +10974,16 @@ const INPUT_SIZE_72: usize = 2; const IN_72: usize = 2; const OUT_72: usize = 1; fn aiur_fn_72( - inp: [G; IN_72], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; + record.checkpoint(72); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[766].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i)?; } record.function_queries[766].output_at(__i).to_array::() }, _ => aiur_fn_766(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10918,12 +10992,12 @@ fn aiur_fn_72( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[54].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i)?; } record.function_queries[54].output_at(__i).to_array::() }, _ => aiur_fn_54(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_11]; - record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[72].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -10932,72 +11006,73 @@ const INPUT_SIZE_73: usize = 49; const IN_73: usize = 49; const OUT_73: usize = 1; fn aiur_fn_73( - inp: [G; IN_73], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; + record.checkpoint(73); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[72].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i)?; } record.function_queries[72].output_at(__i).to_array::() }, _ => aiur_fn_72(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[71].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i)?; } record.function_queries[71].output_at(__i).to_array::() }, _ => aiur_fn_71(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_45, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_45, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[70].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i)?; } record.function_queries[70].output_at(__i).to_array::() }, _ => aiur_fn_70(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[775].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i)?; } record.function_queries[775].output_at(__i).to_array::() }, _ => aiur_fn_775(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -11007,12 +11082,12 @@ fn aiur_fn_73( let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = G::from_u64(12); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -11025,12 +11100,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -11043,12 +11118,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { @@ -11061,12 +11136,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { @@ -11079,12 +11154,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { @@ -11097,12 +11172,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { @@ -11115,12 +11190,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { @@ -11133,12 +11208,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { @@ -11151,12 +11226,12 @@ fn aiur_fn_73( let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __ret: [G; OUT_73] = [__v_62]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11172,30 +11247,31 @@ const INPUT_SIZE_74: usize = 1; const IN_74: usize = 1; const OUT_74: usize = 2; fn aiur_fn_74( - inp: [G; IN_74], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(74); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_74] = [__v_2, __v_3]; - record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[74].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_74] = [__v_4, __v_7]; - record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[74].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11209,14 +11285,15 @@ const INPUT_SIZE_75: usize = 2; const IN_75: usize = 2; const OUT_75: usize = 9; fn aiur_fn_75( - inp: [G; IN_75], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(75); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); @@ -11228,11 +11305,11 @@ fn aiur_fn_75( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __ret: [G; OUT_75] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; - record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[75].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11240,7 +11317,7 @@ fn aiur_fn_75( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[75].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i)?; } record.function_queries[75].output_at(__i).to_array::() }, _ => aiur_fn_75(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -11251,7 +11328,7 @@ fn aiur_fn_75( let __v_14: G = __r_arr[7]; let __v_15: G = __r_arr[8]; let __ret: [G; OUT_75] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15]; - record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[75].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11267,20 +11344,21 @@ const INPUT_SIZE_76: usize = 1; const IN_76: usize = 1; const OUT_76: usize = 9; fn aiur_fn_76( - inp: [G; IN_76], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(76); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record)? }; let __v_4: G = __b1_out[0]; let __v_5: G = __b1_out[1]; let __v_6: G = __b1_out[2]; @@ -11317,19 +11395,19 @@ fn aiur_fn_76( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __ret: [G; OUT_76] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3]; - record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[76].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(1); let __v_31: G = (__v_29 + __v_30); let __v_32: G = G::from_u64(9); - let __v_33: G = if unconstrained { Bytes2::less_than(&__v_31, &__v_32) } else { bytes2_less_than_value(__v_31, __v_32, record) }; + let __v_33: G = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_32)?; Bytes2::less_than(&__v_31, &__v_32) } else { bytes2_less_than_value(__v_31, __v_32, record)? }; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) }); } - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[75].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i)?; } record.function_queries[75].output_at(__i).to_array::() }, _ => aiur_fn_75(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; @@ -11340,7 +11418,7 @@ fn aiur_fn_76( let __v_42: G = __r_arr[7]; let __v_43: G = __r_arr[8]; let __ret: [G; OUT_76] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[76].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11356,20 +11434,21 @@ const INPUT_SIZE_77: usize = 1; const IN_77: usize = 1; const OUT_77: usize = 10; fn aiur_fn_77( - inp: [G; IN_77], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(77); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record)? }; let __v_4: G = __b1_out[0]; let __v_5: G = __b1_out[1]; let __v_6: G = __b1_out[2]; @@ -11403,13 +11482,13 @@ fn aiur_fn_77( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __ret: [G; OUT_77] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[77].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[75].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i)?; } record.function_queries[75].output_at(__i).to_array::() }, _ => aiur_fn_75(__key, 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]; @@ -11420,13 +11499,13 @@ fn aiur_fn_77( let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(9); - let __v_39: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_38) } else { bytes2_less_than_value(__v_28, __v_38, record) }; + let __v_39: G = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_38)?; Bytes2::less_than(&__v_28, &__v_38) } else { bytes2_less_than_value(__v_28, __v_38, record)? }; let __v_40: G = G::from_u64(1); if (__v_39 != __v_40) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_40.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) }); } let __ret: [G; OUT_77] = [__v_14, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[77].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11442,20 +11521,21 @@ const INPUT_SIZE_78: usize = 1; const IN_78: usize = 1; const OUT_78: usize = 10; fn aiur_fn_78( - inp: [G; IN_78], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(78); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_2); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_2, record)? }; let __v_4: G = __b1_out[0]; let __v_5: G = __b1_out[1]; let __v_6: G = __b1_out[2]; @@ -11489,13 +11569,13 @@ fn aiur_fn_78( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __ret: [G; OUT_78] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3]; - record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[78].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_26 + __v_27); - let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[75].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i)?; } record.function_queries[75].output_at(__i).to_array::() }, _ => aiur_fn_75(__key, 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]; @@ -11506,7 +11586,7 @@ fn aiur_fn_78( let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; let __ret: [G; OUT_78] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; - record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[78].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11522,34 +11602,35 @@ const INPUT_SIZE_79: usize = 9; const IN_79: usize = 9; const OUT_79: usize = 2; fn aiur_fn_79( - inp: [G; IN_79], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(79); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_79] = [__v_12, __v_0]; - record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[79].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -11559,7 +11640,7 @@ fn aiur_fn_79( 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_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -11568,13 +11649,13 @@ fn aiur_fn_79( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_29, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_79] = [__v_30, __v_28]; - record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[79].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11588,38 +11669,39 @@ const INPUT_SIZE_80: usize = 10; const IN_80: usize = 10; const OUT_80: usize = 2; fn aiur_fn_80( - inp: [G; IN_80], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(80); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_80] = [__v_0, __v_1]; - record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[80].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = __r_arr[2]; @@ -11628,11 +11710,11 @@ fn aiur_fn_80( let __v_21: G = __r_arr[5]; let __v_22: G = __r_arr[6]; let __v_23: G = __r_arr[7]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __ret: [G; OUT_80] = [__v_24, __v_25]; - record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[80].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11646,21 +11728,22 @@ const INPUT_SIZE_81: usize = 1; const IN_81: usize = 1; const OUT_81: usize = 2; fn aiur_fn_81( - inp: [G; IN_81], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(81); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(4); - let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) }; + let __v_5: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_4)?; Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record)? }; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("invalid lambda mode".to_string()) }); @@ -11669,25 +11752,25 @@ fn aiur_fn_81( 0u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_7, __v_3]; - record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[81].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_81] = [__v_7, __v_3]; - record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[81].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __ret: [G; OUT_81] = [__v_7, __v_3]; - record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[81].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __ret: [G; OUT_81] = [__v_7, __v_3]; - record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[81].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11706,21 +11789,22 @@ const INPUT_SIZE_82: usize = 1; const IN_82: usize = 1; const OUT_82: usize = 3; fn aiur_fn_82( - inp: [G; IN_82], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(82); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(8); - let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) }; + let __v_5: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_4)?; Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record)? }; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("invalid forall mode".to_string()) }); @@ -11730,56 +11814,56 @@ fn aiur_fn_82( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); let __v_8: G = G::from_u64(0); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(1); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(3); let __v_8: G = G::from_u64(1); let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11798,29 +11882,30 @@ const INPUT_SIZE_83: usize = 9; const IN_83: usize = 9; const OUT_83: usize = 2; fn aiur_fn_83( - inp: [G; IN_83], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(83); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -11847,24 +11932,24 @@ fn aiur_fn_83( return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) }); } let __ret: [G; OUT_83] = [__v_10, __v_11]; - record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[83].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_83] = [__v_10, __v_11]; - record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[83].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[81].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i)?; } record.function_queries[81].output_at(__i).to_array::() }, _ => aiur_fn_81(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -11873,14 +11958,14 @@ fn aiur_fn_83( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[83].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i)?; } record.function_queries[83].output_at(__i).to_array::() }, _ => aiur_fn_83(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = G::from_u64(8); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_22, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_22, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_83] = [__v_26, __v_23]; - record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[83].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11894,29 +11979,30 @@ const INPUT_SIZE_84: usize = 9; const IN_84: usize = 9; const OUT_84: usize = 2; fn aiur_fn_84( - inp: [G; IN_84], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(84); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -11943,25 +12029,25 @@ fn aiur_fn_84( return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) }); } let __ret: [G; OUT_84] = [__v_10, __v_11]; - record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[84].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_84] = [__v_10, __v_11]; - record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[84].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -11970,14 +12056,14 @@ fn aiur_fn_84( let __v_20: G = __r_arr[5]; let __v_21: G = __r_arr[6]; let __v_22: G = __r_arr[7]; - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[84].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i)?; } record.function_queries[84].output_at(__i).to_array::() }, _ => aiur_fn_84(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = G::from_u64(9); let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 18] = [__v_25, __v_10, __v_11, __v_13, __v_23, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 18] = [__v_25, __v_10, __v_11, __v_13, __v_23, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_84] = [__v_27, __v_24]; - record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[84].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11991,14 +12077,15 @@ const INPUT_SIZE_85: usize = 1; const IN_85: usize = 1; const OUT_85: usize = 2; fn aiur_fn_85( - inp: [G; IN_85], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + record.checkpoint(85); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, 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]; @@ -12013,21 +12100,21 @@ fn aiur_fn_85( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_13, __v_10]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_13, __v_10]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12037,18 +12124,18 @@ fn aiur_fn_85( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_24, __v_21]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12058,18 +12145,18 @@ fn aiur_fn_85( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_24, __v_21]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12079,42 +12166,42 @@ fn aiur_fn_85( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(4); - let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 18] = [__v_22, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_23, __v_21]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_13, __v_10]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_11: G = G::from_u64(6); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_13, __v_10]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) }); } - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -12140,65 +12227,65 @@ fn aiur_fn_85( if (__v_33 != __v_34) { return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("non-canonical application telescope".to_string()) }); } - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_35, __v_36]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_33, __v_34]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) }); } - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[83].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i)?; } record.function_queries[83].output_at(__i).to_array::() }, _ => aiur_fn_83(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_13, __v_14]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); if (__v_11 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) }); } - let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[84].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i)?; } record.function_queries[84].output_at(__i).to_array::() }, _ => aiur_fn_84(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_13, __v_14]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __ret: [G; OUT_85] = [__v_11, __v_12]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { let __v_11: G = G::from_u64(11); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_13, __v_10]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12212,21 +12299,22 @@ const INPUT_SIZE_86: usize = 9; const IN_86: usize = 9; const OUT_86: usize = 2; fn aiur_fn_86( - inp: [G; IN_86], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(86); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); @@ -12235,7 +12323,7 @@ fn aiur_fn_86( 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 __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(0); @@ -12245,15 +12333,15 @@ fn aiur_fn_86( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = (__v_17 + __v_26); @@ -12263,9 +12351,9 @@ fn aiur_fn_86( } let __v_35: G = G::from_u64(10); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 18] = [__v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27, __v_29, __v_31, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 18] = [__v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27, __v_29, __v_31, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_37, __v_32]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -12274,39 +12362,40 @@ const INPUT_SIZE_87: usize = 17; const IN_87: usize = 17; const OUT_87: usize = 9; fn aiur_fn_87( - inp: [G; IN_87], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(87); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[87].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -12315,7 +12404,7 @@ fn aiur_fn_87( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, 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]; @@ -12326,10 +12415,10 @@ fn aiur_fn_87( let __v_33: G = __r_arr[7]; let __v_34: G = __r_arr[8]; let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_37: G = G::from_u64(0); let __ret: [G; OUT_87] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; - record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[87].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12343,14 +12432,15 @@ const INPUT_SIZE_88: usize = 1; const IN_88: usize = 1; const OUT_88: usize = 10; fn aiur_fn_88( - inp: [G; IN_88], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(88); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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]; @@ -12363,18 +12453,18 @@ fn aiur_fn_88( let __v_10: G = __r_arr[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[88].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i)?; } record.function_queries[88].output_at(__i).to_array::() }, _ => aiur_fn_88(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -12385,7 +12475,7 @@ fn aiur_fn_88( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, 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]; @@ -12396,7 +12486,7 @@ fn aiur_fn_88( let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __ret: [G; OUT_88] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12405,7 +12495,7 @@ fn aiur_fn_88( } }, 1u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[88].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i)?; } record.function_queries[88].output_at(__i).to_array::() }, _ => aiur_fn_88(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12416,7 +12506,7 @@ fn aiur_fn_88( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[88].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i)?; } record.function_queries[88].output_at(__i).to_array::() }, _ => aiur_fn_88(__key, 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]; @@ -12428,15 +12518,15 @@ fn aiur_fn_88( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(2); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[88].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i)?; } record.function_queries[88].output_at(__i).to_array::() }, _ => aiur_fn_88(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -12447,7 +12537,7 @@ fn aiur_fn_88( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[88].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i)?; } record.function_queries[88].output_at(__i).to_array::() }, _ => aiur_fn_88(__key, 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]; @@ -12459,17 +12549,17 @@ fn aiur_fn_88( let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; let __v_31: G = G::from_u64(3); - let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_34: G = G::from_u64(0); let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_11: G = G::from_u64(4); let __ret: [G; OUT_88] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12483,208 +12573,209 @@ const INPUT_SIZE_89: usize = 1; const IN_89: usize = 1; const OUT_89: usize = 2; fn aiur_fn_89( - inp: [G; IN_89], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(89); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_89] = [__v_97, __v_96]; - record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[89].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12853,37 +12944,38 @@ const INPUT_SIZE_90: usize = 9; const IN_90: usize = 9; const OUT_90: usize = 2; fn aiur_fn_90( - inp: [G; IN_90], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(90); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_90] = [__v_12, __v_0]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -12892,13 +12984,13 @@ fn aiur_fn_90( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_90] = [__v_23, __v_21]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12912,34 +13004,35 @@ const INPUT_SIZE_91: usize = 9; const IN_91: usize = 9; const OUT_91: usize = 2; fn aiur_fn_91( - inp: [G; IN_91], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(91); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_91] = [__v_12, __v_0]; - record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[91].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[88].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i)?; } record.function_queries[88].output_at(__i).to_array::() }, _ => aiur_fn_88(__key, 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]; @@ -12950,7 +13043,7 @@ fn aiur_fn_91( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -12959,14 +13052,14 @@ fn aiur_fn_91( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[91].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i)?; } record.function_queries[91].output_at(__i).to_array::() }, _ => aiur_fn_91(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 9] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_91] = [__v_32, __v_29]; - record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[91].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12980,37 +13073,38 @@ const INPUT_SIZE_92: usize = 9; const IN_92: usize = 9; const OUT_92: usize = 2; fn aiur_fn_92( - inp: [G; IN_92], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(92); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_92] = [__v_12, __v_0]; - record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[92].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -13019,13 +13113,13 @@ fn aiur_fn_92( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[92].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i)?; } record.function_queries[92].output_at(__i).to_array::() }, _ => aiur_fn_92(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_22, __v_10, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_92] = [__v_23, __v_21]; - record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[92].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13039,14 +13133,15 @@ const INPUT_SIZE_93: usize = 1; const IN_93: usize = 1; const OUT_93: usize = 2; fn aiur_fn_93( - inp: [G; IN_93], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(93); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13056,11 +13151,11 @@ fn aiur_fn_93( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_93] = [__v_10, __v_11]; - record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[93].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13069,14 +13164,15 @@ const INPUT_SIZE_94: usize = 1; const IN_94: usize = 1; const OUT_94: usize = 2; fn aiur_fn_94( - inp: [G; IN_94], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(94); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13086,11 +13182,11 @@ fn aiur_fn_94( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[92].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i)?; } record.function_queries[92].output_at(__i).to_array::() }, _ => aiur_fn_92(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_94] = [__v_10, __v_11]; - record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[94].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13099,14 +13195,15 @@ const INPUT_SIZE_95: usize = 1; const IN_95: usize = 1; const OUT_95: usize = 2; fn aiur_fn_95( - inp: [G; IN_95], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(95); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13116,11 +13213,11 @@ fn aiur_fn_95( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[91].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i)?; } record.function_queries[91].output_at(__i).to_array::() }, _ => aiur_fn_91(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_95] = [__v_10, __v_11]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13129,75 +13226,76 @@ const INPUT_SIZE_96: usize = 1; const IN_96: usize = 1; const OUT_96: usize = 2; fn aiur_fn_96( - inp: [G; IN_96], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(96); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(0); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(2); let __ret: [G; OUT_96] = [__v_1, __v_2]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13211,20 +13309,21 @@ const INPUT_SIZE_97: usize = 1; const IN_97: usize = 1; const OUT_97: usize = 13; fn aiur_fn_97( - inp: [G; IN_97], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(97); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[96].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[96].bump_multiplicity(__i)?; } record.function_queries[96].output_at(__i).to_array::() }, _ => aiur_fn_96(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -13234,14 +13333,14 @@ fn aiur_fn_97( let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; let __v_13: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __ret: [G; OUT_97] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17]; - record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[97].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13250,14 +13349,15 @@ const INPUT_SIZE_98: usize = 1; const IN_98: usize = 1; const OUT_98: usize = 10; fn aiur_fn_98( - inp: [G; IN_98], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(98); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13267,11 +13367,11 @@ fn aiur_fn_98( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_98] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[98].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13280,34 +13380,35 @@ const INPUT_SIZE_99: usize = 9; const IN_99: usize = 9; const OUT_99: usize = 2; fn aiur_fn_99( - inp: [G; IN_99], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(99); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 11] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_99] = [__v_12, __v_0]; - record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[99].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13317,10 +13418,10 @@ fn aiur_fn_99( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -13329,13 +13430,13 @@ fn aiur_fn_99( let __v_26: G = __r_arr[5]; let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[99].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[99].bump_multiplicity(__i)?; } record.function_queries[99].output_at(__i).to_array::() }, _ => aiur_fn_99(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 11] = [__v_31, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_99] = [__v_32, __v_30]; - record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[99].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13349,17 +13450,18 @@ const INPUT_SIZE_100: usize = 1; const IN_100: usize = 1; const OUT_100: usize = 45; fn aiur_fn_100( - inp: [G; IN_100], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(100); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record)? }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -13368,7 +13470,7 @@ fn aiur_fn_100( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -13378,7 +13480,7 @@ fn aiur_fn_100( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -13388,7 +13490,7 @@ fn aiur_fn_100( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -13398,7 +13500,7 @@ fn aiur_fn_100( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -13408,7 +13510,7 @@ fn aiur_fn_100( let __v_44: G = __r_arr[6]; let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; @@ -13418,10 +13520,10 @@ fn aiur_fn_100( let __v_53: G = __r_arr[6]; let __v_54: G = __r_arr[7]; let __v_55: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_57]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -13431,11 +13533,11 @@ fn aiur_fn_100( let __v_64: G = __r_arr[6]; let __v_65: G = __r_arr[7]; let __v_66: G = __r_arr[8]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[99].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[99].bump_multiplicity(__i)?; } record.function_queries[99].output_at(__i).to_array::() }, _ => aiur_fn_99(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __ret: [G; OUT_100] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68]; - record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[100].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13444,21 +13546,22 @@ const INPUT_SIZE_101: usize = 1; const IN_101: usize = 1; const OUT_101: usize = 0; fn aiur_fn_101( - inp: [G; IN_101], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(101); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(2); - let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) }; + let __v_2: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_1)?; Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record)? }; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) }); } let __ret: [G; OUT_101] = []; - record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[101].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13467,18 +13570,19 @@ const INPUT_SIZE_102: usize = 1; const IN_102: usize = 1; const OUT_102: usize = 11; fn aiur_fn_102( - inp: [G; IN_102], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(102); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13488,11 +13592,11 @@ fn aiur_fn_102( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; - record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[102].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13501,36 +13605,37 @@ const INPUT_SIZE_103: usize = 1; const IN_103: usize = 1; const OUT_103: usize = 1; fn aiur_fn_103( - inp: [G; IN_103], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(103); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); let __ret: [G; OUT_103] = [__v_1]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_103] = [__v_1]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_103] = [__v_1]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(3); let __ret: [G; OUT_103] = [__v_1]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13544,19 +13649,20 @@ const INPUT_SIZE_104: usize = 1; const IN_104: usize = 1; const OUT_104: usize = 11; fn aiur_fn_104( - inp: [G; IN_104], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(104); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -13566,11 +13672,11 @@ fn aiur_fn_104( let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; let __v_12: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_104] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13579,18 +13685,19 @@ const INPUT_SIZE_105: usize = 1; const IN_105: usize = 1; const OUT_105: usize = 35; fn aiur_fn_105( - inp: [G; IN_105], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(105); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13600,7 +13707,7 @@ fn aiur_fn_105( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -13610,7 +13717,7 @@ fn aiur_fn_105( let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -13620,7 +13727,7 @@ fn aiur_fn_105( let __v_27: G = __r_arr[6]; let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __v_32: G = __r_arr[2]; @@ -13630,11 +13737,11 @@ fn aiur_fn_105( let __v_36: G = __r_arr[6]; let __v_37: G = __r_arr[7]; let __v_38: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __ret: [G; OUT_105] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13643,34 +13750,35 @@ const INPUT_SIZE_106: usize = 9; const IN_106: usize = 9; const OUT_106: usize = 2; fn aiur_fn_106( - inp: [G; IN_106], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(106); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 36] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_106] = [__v_12, __v_0]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, 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]; @@ -13706,7 +13814,7 @@ fn aiur_fn_106( let __v_42: G = __r_arr[32]; let __v_43: G = __r_arr[33]; let __v_44: G = __r_arr[34]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -13715,13 +13823,13 @@ fn aiur_fn_106( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 36] = [__v_55, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_106] = [__v_56, __v_54]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13735,17 +13843,18 @@ const INPUT_SIZE_107: usize = 1; const IN_107: usize = 1; const OUT_107: usize = 28; fn aiur_fn_107( - inp: [G; IN_107], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(107); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record)? }; let __v_3: G = __b1_out[0]; let __v_4: G = __b1_out[1]; let __v_5: G = __b1_out[2]; @@ -13754,7 +13863,7 @@ fn aiur_fn_107( let __v_8: G = __b1_out[5]; let __v_9: G = __b1_out[6]; let __v_10: G = __b1_out[7]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -13764,7 +13873,7 @@ fn aiur_fn_107( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -13774,7 +13883,7 @@ fn aiur_fn_107( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; @@ -13784,10 +13893,10 @@ fn aiur_fn_107( let __v_35: G = __r_arr[6]; let __v_36: G = __r_arr[7]; let __v_37: G = __r_arr[8]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -13797,11 +13906,11 @@ fn aiur_fn_107( let __v_46: G = __r_arr[6]; let __v_47: G = __r_arr[7]; let __v_48: G = __r_arr[8]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_107] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13810,14 +13919,15 @@ const INPUT_SIZE_108: usize = 1; const IN_108: usize = 1; const OUT_108: usize = 10; fn aiur_fn_108( - inp: [G; IN_108], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(108); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13827,11 +13937,11 @@ fn aiur_fn_108( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_108] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; - record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[108].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13840,14 +13950,15 @@ const INPUT_SIZE_109: usize = 1; const IN_109: usize = 1; const OUT_109: usize = 18; fn aiur_fn_109( - inp: [G; IN_109], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(109); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -13857,7 +13968,7 @@ fn aiur_fn_109( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -13867,11 +13978,11 @@ fn aiur_fn_109( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_109] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; - record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[109].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13880,19 +13991,20 @@ const INPUT_SIZE_110: usize = 1; const IN_110: usize = 1; const OUT_110: usize = 46; fn aiur_fn_110( - inp: [G; IN_110], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(110); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[97].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i)?; } record.function_queries[97].output_at(__i).to_array::() }, _ => aiur_fn_97(__key, 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]; @@ -13909,11 +14021,11 @@ fn aiur_fn_110( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, 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]; @@ -13945,11 +14057,11 @@ fn aiur_fn_110( let __v_31: G = G::from_u64(1); let __v_32: G = G::from_u64(0); let __ret: [G; OUT_110] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[100].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[100].bump_multiplicity(__i)?; } record.function_queries[100].output_at(__i).to_array::() }, _ => aiur_fn_100(__key, 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]; @@ -13997,7 +14109,7 @@ fn aiur_fn_110( let __v_47: G = __r_arr[44]; let __v_48: G = G::from_u64(2); let __ret: [G; OUT_110] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14011,34 +14123,35 @@ const INPUT_SIZE_111: usize = 9; const IN_111: usize = 9; const OUT_111: usize = 2; fn aiur_fn_111( - inp: [G; IN_111], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(111); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 47] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_111] = [__v_12, __v_0]; - record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[111].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, 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]; @@ -14085,7 +14198,7 @@ fn aiur_fn_111( let __v_53: G = __r_arr[43]; let __v_54: G = __r_arr[44]; let __v_55: G = __r_arr[45]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -14094,13 +14207,13 @@ fn aiur_fn_111( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 47] = [__v_66, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_111] = [__v_67, __v_65]; - record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[111].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14114,17 +14227,18 @@ const INPUT_SIZE_112: usize = 2; const IN_112: usize = 2; const OUT_112: usize = 46; fn aiur_fn_112( - inp: [G; IN_112], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(112); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[97].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i)?; } record.function_queries[97].output_at(__i).to_array::() }, _ => aiur_fn_97(__key, 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]; @@ -14141,11 +14255,11 @@ fn aiur_fn_112( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[100].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[100].bump_multiplicity(__i)?; } record.function_queries[100].output_at(__i).to_array::() }, _ => aiur_fn_100(__key, 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]; @@ -14193,11 +14307,11 @@ fn aiur_fn_112( let __v_46: G = __r_arr[44]; let __v_47: G = G::from_u64(1); let __ret: [G; OUT_112] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[102].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i)?; } record.function_queries[102].output_at(__i).to_array::() }, _ => aiur_fn_102(__key, 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]; @@ -14212,11 +14326,11 @@ fn aiur_fn_112( let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, 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]; @@ -14231,11 +14345,11 @@ fn aiur_fn_112( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[109].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i)?; } record.function_queries[109].output_at(__i).to_array::() }, _ => aiur_fn_109(__key, 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]; @@ -14257,11 +14371,11 @@ fn aiur_fn_112( let __v_20: G = G::from_u64(4); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[108].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i)?; } record.function_queries[108].output_at(__i).to_array::() }, _ => aiur_fn_108(__key, 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]; @@ -14275,11 +14389,11 @@ fn aiur_fn_112( let __v_12: G = G::from_u64(5); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[108].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i)?; } record.function_queries[108].output_at(__i).to_array::() }, _ => aiur_fn_108(__key, 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]; @@ -14293,11 +14407,11 @@ fn aiur_fn_112( let __v_12: G = G::from_u64(6); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[108].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i)?; } record.function_queries[108].output_at(__i).to_array::() }, _ => aiur_fn_108(__key, 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]; @@ -14311,7 +14425,7 @@ fn aiur_fn_112( let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14325,31 +14439,32 @@ const INPUT_SIZE_113: usize = 10; const IN_113: usize = 10; const OUT_113: usize = 46; fn aiur_fn_113( - inp: [G; IN_113], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; + record.checkpoint(113); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_0.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(8); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_113] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 13u64 => { @@ -14363,7 +14478,7 @@ fn aiur_fn_113( if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, 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]; @@ -14411,7 +14526,7 @@ fn aiur_fn_113( let __v_61: G = __r_arr[44]; let __v_62: G = __r_arr[45]; let __ret: [G; OUT_113] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14425,14 +14540,15 @@ const INPUT_SIZE_114: usize = 1; const IN_114: usize = 1; const OUT_114: usize = 49; fn aiur_fn_114( - inp: [G; IN_114], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + record.checkpoint(114); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -14445,7 +14561,7 @@ fn aiur_fn_114( let __v_10: G = __r_arr[9]; let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() { 12u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(8); @@ -14463,7 +14579,7 @@ fn aiur_fn_114( if (__v_16 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) }); } - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; @@ -14563,7 +14679,7 @@ fn aiur_fn_114( let __v_54: G = __mc_out___mc_0[43]; let __v_55: G = __mc_out___mc_0[44]; let __v_56: G = __mc_out___mc_0[45]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -14573,10 +14689,10 @@ fn aiur_fn_114( let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; let __v_65: G = __r_arr[8]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -14586,10 +14702,10 @@ fn aiur_fn_114( let __v_74: G = __r_arr[6]; let __v_75: G = __r_arr[7]; let __v_76: G = __r_arr[8]; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[92].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i)?; } record.function_queries[92].output_at(__i).to_array::() }, _ => aiur_fn_92(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_78]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_78]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = __r_arr[1]; let __v_81: G = __r_arr[2]; @@ -14599,11 +14715,11 @@ fn aiur_fn_114( let __v_85: G = __r_arr[6]; let __v_86: G = __r_arr[7]; let __v_87: G = __r_arr[8]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[91].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i)?; } record.function_queries[91].output_at(__i).to_array::() }, _ => aiur_fn_91(__key, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; let __ret: [G; OUT_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_66, __v_77, __v_88, __v_89]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -14612,53 +14728,195 @@ const INPUT_SIZE_115: usize = 1; const IN_115: usize = 1; const OUT_115: usize = 2; fn aiur_fn_115( - inp: [G; IN_115], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(115); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[763].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i)?; } record.function_queries[763].output_at(__i).to_array::() }, _ => aiur_fn_763(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_115] = [__v_5, __v_7]; - record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[115].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_115] = [__v_0, __v_7]; - record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[115].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_116: usize = 1; -const IN_116: usize = 1; -const OUT_116: usize = 1; +const INPUT_SIZE_116: usize = 8; +const IN_116: usize = 8; +const OUT_116: usize = 9; fn aiur_fn_116( - inp: [G; IN_116], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(116); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = G::from_u64(1); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::add(&__v_0, &__v_8) } else { bytes2_add_value(__v_0, __v_8, record)? }; + let __v_9: G = __b2_add.0; + let __v_10: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_10)?; Bytes2::add(&__v_1, &__v_10) } else { bytes2_add_value(__v_1, __v_10, record)? }; + let __v_11: G = __b2_add.0; + let __v_12: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_12)?; Bytes2::add(&__v_2, &__v_12) } else { bytes2_add_value(__v_2, __v_12, record)? }; + let __v_13: G = __b2_add.0; + let __v_14: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_14)?; Bytes2::add(&__v_3, &__v_14) } else { bytes2_add_value(__v_3, __v_14, record)? }; + let __v_15: G = __b2_add.0; + let __v_16: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_16)?; Bytes2::add(&__v_4, &__v_16) } else { bytes2_add_value(__v_4, __v_16, record)? }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_18)?; Bytes2::add(&__v_5, &__v_18) } else { bytes2_add_value(__v_5, __v_18, record)? }; + let __v_19: G = __b2_add.0; + let __v_20: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_20)?; Bytes2::add(&__v_6, &__v_20) } else { bytes2_add_value(__v_6, __v_20, record)? }; + let __v_21: G = __b2_add.0; + let __v_22: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_22)?; Bytes2::add(&__v_7, &__v_22) } else { bytes2_add_value(__v_7, __v_22, record)? }; + let __v_23: G = __b2_add.0; + let __v_24: G = __b2_add.1; + let __ret: [G; OUT_116] = [__v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_24]; + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }) +} + +const INPUT_SIZE_117: usize = 16; +const IN_117: usize = 16; +const OUT_117: usize = 9; +fn aiur_fn_117( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_117], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(117); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::add(&__v_0, &__v_8) } else { bytes2_add_value(__v_0, __v_8, record)? }; + let __v_16: G = __b2_add.0; + let __v_17: G = __b2_add.1; + let __v_18: G = G::from_u64(1); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_18)?; Bytes2::add(&__v_16, &__v_18) } else { bytes2_add_value(__v_16, __v_18, record)? }; + let __v_19: G = __b2_add.0; + let __v_20: G = __b2_add.1; + let __v_21: G = (__v_17 + __v_20); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_9)?; Bytes2::add(&__v_1, &__v_9) } else { bytes2_add_value(__v_1, __v_9, record)? }; + let __v_22: G = __b2_add.0; + let __v_23: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_21)?; Bytes2::add(&__v_22, &__v_21) } else { bytes2_add_value(__v_22, __v_21, record)? }; + let __v_24: G = __b2_add.0; + let __v_25: G = __b2_add.1; + let __v_26: G = (__v_23 + __v_25); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_10)?; Bytes2::add(&__v_2, &__v_10) } else { bytes2_add_value(__v_2, __v_10, record)? }; + let __v_27: G = __b2_add.0; + let __v_28: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_26)?; Bytes2::add(&__v_27, &__v_26) } else { bytes2_add_value(__v_27, __v_26, record)? }; + let __v_29: G = __b2_add.0; + let __v_30: G = __b2_add.1; + let __v_31: G = (__v_28 + __v_30); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_11)?; Bytes2::add(&__v_3, &__v_11) } else { bytes2_add_value(__v_3, __v_11, record)? }; + let __v_32: G = __b2_add.0; + let __v_33: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_31)?; Bytes2::add(&__v_32, &__v_31) } else { bytes2_add_value(__v_32, __v_31, record)? }; + let __v_34: G = __b2_add.0; + let __v_35: G = __b2_add.1; + let __v_36: G = (__v_33 + __v_35); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_12)?; Bytes2::add(&__v_4, &__v_12) } else { bytes2_add_value(__v_4, __v_12, record)? }; + let __v_37: G = __b2_add.0; + let __v_38: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_37, &__v_36)?; Bytes2::add(&__v_37, &__v_36) } else { bytes2_add_value(__v_37, __v_36, record)? }; + let __v_39: G = __b2_add.0; + let __v_40: G = __b2_add.1; + let __v_41: G = (__v_38 + __v_40); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_13)?; Bytes2::add(&__v_5, &__v_13) } else { bytes2_add_value(__v_5, __v_13, record)? }; + let __v_42: G = __b2_add.0; + let __v_43: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_42, &__v_41)?; Bytes2::add(&__v_42, &__v_41) } else { bytes2_add_value(__v_42, __v_41, record)? }; + let __v_44: G = __b2_add.0; + let __v_45: G = __b2_add.1; + let __v_46: G = (__v_43 + __v_45); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_14)?; Bytes2::add(&__v_6, &__v_14) } else { bytes2_add_value(__v_6, __v_14, record)? }; + let __v_47: G = __b2_add.0; + let __v_48: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_47, &__v_46)?; Bytes2::add(&__v_47, &__v_46) } else { bytes2_add_value(__v_47, __v_46, record)? }; + let __v_49: G = __b2_add.0; + let __v_50: G = __b2_add.1; + let __v_51: G = (__v_48 + __v_50); + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_15)?; Bytes2::add(&__v_7, &__v_15) } else { bytes2_add_value(__v_7, __v_15, record)? }; + let __v_52: G = __b2_add.0; + let __v_53: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_51)?; Bytes2::add(&__v_52, &__v_51) } else { bytes2_add_value(__v_52, __v_51, record)? }; + let __v_54: G = __b2_add.0; + let __v_55: G = __b2_add.1; + let __v_56: G = (__v_53 + __v_55); + let __ret: [G; OUT_117] = [__v_19, __v_24, __v_29, __v_34, __v_39, __v_44, __v_49, __v_54, __v_56]; + record.function_queries[117].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }) +} + +const INPUT_SIZE_118: usize = 1; +const IN_118: usize = 1; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_118], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(118); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -14682,46 +14940,38 @@ fn aiur_fn_116( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_23]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_118] = [__v_23]; + record.function_queries[118].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_11: G = G::from_u64(1); - let __v_12: G = G::from_u64(0); - let __v_13: G = G::from_u64(0); - let __v_14: G = 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 __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; - let __v_19: G = __r_arr[0]; - let __v_20: G = __r_arr[1]; - let __v_21: G = __r_arr[2]; - let __v_22: G = __r_arr[3]; - let __v_23: G = __r_arr[4]; - let __v_24: G = __r_arr[5]; - let __v_25: G = __r_arr[6]; - let __v_26: G = __r_arr[7]; - let __v_27: G = __r_arr[8]; - match __v_27.as_canonical_u64() { + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = __r_arr[3]; + let __v_15: G = __r_arr[4]; + let __v_16: G = __r_arr[5]; + let __v_17: G = __r_arr[6]; + let __v_18: G = __r_arr[7]; + let __v_19: G = __r_arr[8]; + match __v_19.as_canonical_u64() { 0u64 => { - let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_29]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 10] = [__v_20, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_118] = [__v_21]; + record.function_queries[118].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 10] = [__v_28, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_116] = [__v_30]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_118] = [__v_22]; + record.function_queries[118].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14733,20 +14983,21 @@ fn aiur_fn_116( }) } -const INPUT_SIZE_117: usize = 3; -const IN_117: usize = 3; -const OUT_117: usize = 1; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_119: usize = 3; +const IN_119: usize = 3; +const OUT_119: usize = 1; +fn aiur_fn_119( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], 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]; - let __v_2: G = inp[2]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(119); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -14761,21 +15012,24 @@ fn aiur_fn_117( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_117] = [__v_1]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_119] = [__v_1]; + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, - _ => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + 1u64 => { + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_117] = [__v_13]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_119] = [__v_13]; + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, } }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -14790,54 +15044,70 @@ fn aiur_fn_117( 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_117] = [__v_0]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_119] = [__v_0]; + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, - _ => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + 1u64 => { + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_117] = [__v_23]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_119] = [__v_23]; + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, } }, 0u64 => { - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; - let __v_23: G = __r_arr[0]; - let __v_24: G = __r_arr[1]; - let __v_25: G = __r_arr[2]; - let __v_26: G = __r_arr[3]; - let __v_27: G = __r_arr[4]; - let __v_28: G = __r_arr[5]; - let __v_29: G = __r_arr[6]; - let __v_30: G = __r_arr[7]; - let __v_31: G = __r_arr[8]; + let __mc_out___mc_0: [G; 9] = '__mc_0: { match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[14].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i)?; } record.function_queries[14].output_at(__i).to_array::() }, _ => aiur_fn_14(__key, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __v_31: G = __r_arr[8]; + break '__mc_0 [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; + }, + 1u64 => { + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __v_31: G = __r_arr[8]; + break '__mc_0 [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, +} + }; + let __v_23: G = __mc_out___mc_0[0]; + let __v_24: G = __mc_out___mc_0[1]; + let __v_25: G = __mc_out___mc_0[2]; + let __v_26: G = __mc_out___mc_0[3]; + let __v_27: G = __mc_out___mc_0[4]; + let __v_28: G = __mc_out___mc_0[5]; + let __v_29: G = __mc_out___mc_0[6]; + let __v_30: G = __mc_out___mc_0[7]; + let __v_31: G = __mc_out___mc_0[8]; 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 __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __v_40: G = __r_arr[1]; - let __v_41: G = __r_arr[2]; - let __v_42: G = __r_arr[3]; - let __v_43: G = __r_arr[4]; - let __v_44: G = __r_arr[5]; - let __v_45: G = __r_arr[6]; - let __v_46: G = __r_arr[7]; - let __v_47: G = __r_arr[8]; - let __v_48: G = (__v_31 + __v_47); - let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; - let __v_50: G = __r_arr[0]; - let __v_51: G = { let __values: [G; 10] = [__v_49, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_51]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12, __v_22, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = { let __values: [G; 10] = [__v_32, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_119] = [__v_34]; + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14852,125 +15122,128 @@ 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_120: usize = 2; +const IN_120: usize = 2; +const OUT_120: usize = 1; +fn aiur_fn_120( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], 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]; + record.checkpoint(120); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_118] = [__v_3]; - record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_120] = [__v_3]; + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_119: usize = 16; -const IN_119: usize = 16; -const OUT_119: usize = 9; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_121: usize = 16; +const IN_121: usize = 16; +const OUT_121: usize = 9; +fn aiur_fn_121( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_0, &__v_8) } else { bytes2_sub_value(__v_0, __v_8, record) }; + record.checkpoint(121); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::sub(&__v_0, &__v_8) } else { bytes2_sub_value(__v_0, __v_8, record)? }; let __v_16: G = __b2_sub.0; let __v_17: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_1, &__v_9) } else { bytes2_sub_value(__v_1, __v_9, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_9)?; Bytes2::sub(&__v_1, &__v_9) } else { bytes2_sub_value(__v_1, __v_9, record)? }; let __v_18: G = __b2_sub.0; let __v_19: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_18, &__v_17) } else { bytes2_sub_value(__v_18, __v_17, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_17)?; Bytes2::sub(&__v_18, &__v_17) } else { bytes2_sub_value(__v_18, __v_17, record)? }; let __v_20: G = __b2_sub.0; let __v_21: G = __b2_sub.1; let __v_22: G = (__v_19 + __v_21); - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_2, &__v_10) } else { bytes2_sub_value(__v_2, __v_10, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_10)?; Bytes2::sub(&__v_2, &__v_10) } else { bytes2_sub_value(__v_2, __v_10, record)? }; let __v_23: G = __b2_sub.0; let __v_24: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_23, &__v_22) } else { bytes2_sub_value(__v_23, __v_22, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_22)?; Bytes2::sub(&__v_23, &__v_22) } else { bytes2_sub_value(__v_23, __v_22, record)? }; let __v_25: G = __b2_sub.0; let __v_26: G = __b2_sub.1; let __v_27: G = (__v_24 + __v_26); - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_3, &__v_11) } else { bytes2_sub_value(__v_3, __v_11, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_11)?; Bytes2::sub(&__v_3, &__v_11) } else { bytes2_sub_value(__v_3, __v_11, record)? }; let __v_28: G = __b2_sub.0; let __v_29: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_28, &__v_27) } else { bytes2_sub_value(__v_28, __v_27, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_27)?; Bytes2::sub(&__v_28, &__v_27) } else { bytes2_sub_value(__v_28, __v_27, record)? }; let __v_30: G = __b2_sub.0; let __v_31: G = __b2_sub.1; let __v_32: G = (__v_29 + __v_31); - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_4, &__v_12) } else { bytes2_sub_value(__v_4, __v_12, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_12)?; Bytes2::sub(&__v_4, &__v_12) } else { bytes2_sub_value(__v_4, __v_12, record)? }; let __v_33: G = __b2_sub.0; let __v_34: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_33, &__v_32) } else { bytes2_sub_value(__v_33, __v_32, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_33, &__v_32)?; Bytes2::sub(&__v_33, &__v_32) } else { bytes2_sub_value(__v_33, __v_32, record)? }; let __v_35: G = __b2_sub.0; let __v_36: G = __b2_sub.1; let __v_37: G = (__v_34 + __v_36); - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_5, &__v_13) } else { bytes2_sub_value(__v_5, __v_13, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_13)?; Bytes2::sub(&__v_5, &__v_13) } else { bytes2_sub_value(__v_5, __v_13, record)? }; let __v_38: G = __b2_sub.0; let __v_39: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_38, &__v_37) } else { bytes2_sub_value(__v_38, __v_37, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_38, &__v_37)?; Bytes2::sub(&__v_38, &__v_37) } else { bytes2_sub_value(__v_38, __v_37, record)? }; let __v_40: G = __b2_sub.0; let __v_41: G = __b2_sub.1; let __v_42: G = (__v_39 + __v_41); - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_6, &__v_14) } else { bytes2_sub_value(__v_6, __v_14, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_14)?; Bytes2::sub(&__v_6, &__v_14) } else { bytes2_sub_value(__v_6, __v_14, record)? }; let __v_43: G = __b2_sub.0; let __v_44: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_43, &__v_42) } else { bytes2_sub_value(__v_43, __v_42, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_43, &__v_42)?; Bytes2::sub(&__v_43, &__v_42) } else { bytes2_sub_value(__v_43, __v_42, record)? }; let __v_45: G = __b2_sub.0; let __v_46: G = __b2_sub.1; let __v_47: G = (__v_44 + __v_46); - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_7, &__v_15) } else { bytes2_sub_value(__v_7, __v_15, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_15)?; Bytes2::sub(&__v_7, &__v_15) } else { bytes2_sub_value(__v_7, __v_15, record)? }; let __v_48: G = __b2_sub.0; let __v_49: G = __b2_sub.1; - let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_48, &__v_47) } else { bytes2_sub_value(__v_48, __v_47, record) }; + let __b2_sub: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_48, &__v_47)?; Bytes2::sub(&__v_48, &__v_47) } else { bytes2_sub_value(__v_48, __v_47, record)? }; let __v_50: G = __b2_sub.0; let __v_51: G = __b2_sub.1; let __v_52: G = (__v_49 + __v_51); - let __ret: [G; OUT_119] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; - record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_121] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + record.function_queries[121].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_120: usize = 3; -const IN_120: usize = 3; -const OUT_120: usize = 2; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_122: usize = 3; +const IN_122: usize = 3; +const OUT_122: usize = 2; +fn aiur_fn_122( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], 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]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(122); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -14983,7 +15256,7 @@ fn aiur_fn_120( let __v_12: G = __loaded[9]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -14998,30 +15271,30 @@ fn aiur_fn_120( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_25, __v_2]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_122] = [__v_25, __v_2]; + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_23.as_canonical_u64() { 1u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_26, __v_2]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_122] = [__v_26, __v_2]; + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_120] = [__v_26, __v_27]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_122] = [__v_26, __v_27]; + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15032,7 +15305,7 @@ fn aiur_fn_120( } }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -15048,8 +15321,8 @@ fn aiur_fn_120( match __v_2.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_120] = [__v_0, __v_23]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_122] = [__v_0, __v_23]; + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15061,7 +15334,7 @@ fn aiur_fn_120( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[121].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i)?; } record.function_queries[121].output_at(__i).to_array::() }, _ => aiur_fn_121(__key, 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]; @@ -15073,20 +15346,20 @@ fn aiur_fn_120( let __v_39: G = __r_arr[8]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12, __v_42, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[122].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i)?; } record.function_queries[122].output_at(__i).to_array::() }, _ => aiur_fn_122(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_46, __v_44]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 10] = [__v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_122] = [__v_46, __v_44]; + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[121].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i)?; } record.function_queries[121].output_at(__i).to_array::() }, _ => aiur_fn_121(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -15103,7 +15376,7 @@ fn aiur_fn_120( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[121].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i)?; } record.function_queries[121].output_at(__i).to_array::() }, _ => aiur_fn_121(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -15114,13 +15387,13 @@ fn aiur_fn_120( let __v_46: G = __r_arr[7]; let __v_47: G = __r_arr[8]; let __v_48: G = (__v_31 + __v_47); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12, __v_22, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[122].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i)?; } record.function_queries[122].output_at(__i).to_array::() }, _ => aiur_fn_122(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_120] = [__v_52, __v_50]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + let __v_52: G = { let __values: [G; 10] = [__v_51, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_122] = [__v_52, __v_50]; + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15135,18 +15408,19 @@ fn aiur_fn_120( }) } -const INPUT_SIZE_121: usize = 1; -const IN_121: usize = 1; -const OUT_121: usize = 1; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_123: usize = 1; +const IN_123: usize = 1; +const OUT_123: usize = 1; +fn aiur_fn_123( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(123); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -15161,22 +15435,22 @@ fn aiur_fn_121( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_13]; - record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_123] = [__v_13]; + record.function_queries[123].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - if !unconstrained { let __vi = __v_2; let __vj = __v_3; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_2; let __vj = __v_3; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_4; let __vj = __v_5; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_6; let __vj = __v_7; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_121] = [__v_13]; - record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_123] = [__v_13]; + record.function_queries[123].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15186,18 +15460,19 @@ fn aiur_fn_121( }) } -const INPUT_SIZE_122: usize = 1; -const IN_122: usize = 1; -const OUT_122: usize = 1; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_124: usize = 1; +const IN_124: usize = 1; +const OUT_124: usize = 1; +fn aiur_fn_124( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(124); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -15212,15 +15487,15 @@ fn aiur_fn_122( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_13]; - record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_124] = [__v_13]; + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -15233,25 +15508,25 @@ fn aiur_fn_122( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_25]; - record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_124] = [__v_25]; + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_27]; - record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained); + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_27: G = { let __values: [G; 10] = [__v_23, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_124] = [__v_27]; + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15261,9 +15536,9 @@ fn aiur_fn_122( }, _ => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_122] = [__v_23]; - record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 10] = [__v_22, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_124] = [__v_23]; + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15275,36 +15550,37 @@ fn aiur_fn_122( }) } -const INPUT_SIZE_123: usize = 2; -const IN_123: usize = 2; -const OUT_123: usize = 1; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_125: usize = 2; +const IN_125: usize = 2; +const OUT_125: usize = 1; +fn aiur_fn_125( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], 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]; + record.checkpoint(125); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[122].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i)?; } record.function_queries[122].output_at(__i).to_array::() }, _ => aiur_fn_122(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_123] = [__v_7]; - record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained); + let __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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_125] = [__v_7]; + record.function_queries[125].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_123] = [__v_5]; - record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_125] = [__v_5]; + record.function_queries[125].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15314,21 +15590,22 @@ fn aiur_fn_123( }) } -const INPUT_SIZE_124: usize = 2; -const IN_124: usize = 2; -const OUT_124: usize = 1; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_126: usize = 2; +const IN_126: usize = 2; +const OUT_126: usize = 1; +fn aiur_fn_126( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], 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]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + record.checkpoint(126); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -15342,31 +15619,32 @@ fn aiur_fn_124( match __v_3.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_124] = [__v_13]; - record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_126] = [__v_13]; + record.function_queries[126].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_124] = [__v_13]; - record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_126] = [__v_13]; + record.function_queries[126].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_125: usize = 1; -const IN_125: usize = 1; -const OUT_125: usize = 1; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_127: usize = 1; +const IN_127: usize = 1; +const OUT_127: usize = 1; +fn aiur_fn_127( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(127); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(0); @@ -15378,106 +15656,70 @@ fn aiur_fn_125( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_125] = [__v_14]; - record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_127] = [__v_14]; + record.function_queries[127].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_126: usize = 2; -const IN_126: usize = 2; -const OUT_126: usize = 2; -fn aiur_fn_126( - inp: [G; IN_126], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = G::from_u64(256); - let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - match __v_3.as_canonical_u64() { - 1u64 => { - let __ret: [G; OUT_126] = [__v_0, __v_1]; - record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }, - 0u64 => { - let __v_4: G = G::from_u64(256); - let __v_5: G = (__v_0 - __v_4); - let __v_6: G = G::from_u64(1); - let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_126] = [__v_8, __v_9]; - record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_127: usize = 1; -const IN_127: usize = 1; -const OUT_127: usize = 3; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_128: usize = 1; +const IN_128: usize = 1; +const OUT_128: usize = 3; +fn aiur_fn_128( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __v_3: G = __r_arr[1]; - let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_127] = [__v_2, __v_5, __v_6]; - record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained); + record.checkpoint(128); + let __v_0: G = inp.values()[0]; + let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); + let __v_1: G = G::from_u8(__gb[0]); + let __v_2: G = G::from_u8(__gb[1]); + let __v_3: G = G::from_u8(__gb[2]); + let __v_4: G = G::from_u8(__gb[3]); + let __v_5: G = G::from_u8(__gb[4]); + let __v_6: G = G::from_u8(__gb[5]); + let __v_7: G = G::from_u8(__gb[6]); + let __v_8: G = G::from_u8(__gb[7]); + let __ret: [G; OUT_128] = [__v_1, __v_2, __v_3]; + record.function_queries[128].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_128: usize = 16; -const IN_128: usize = 16; -const OUT_128: usize = 16; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_129: usize = 16; +const IN_129: usize = 16; +const OUT_129: usize = 16; +fn aiur_fn_129( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(129); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; let __v_16: G = (__v_0 * __v_8); let __v_17: G = (__v_0 * __v_9); let __v_18: G = (__v_1 * __v_8); @@ -15591,16 +15833,16 @@ fn aiur_fn_128( let __v_126: G = (__v_7 * __v_14); let __v_127: G = (__v_125 + __v_126); let __v_128: G = (__v_7 * __v_15); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_16]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; let __v_131: G = __r_arr[2]; let __v_132: G = G::from_u64(0); - let __v_133: G = if unconstrained { Bytes2::xor(&__v_129, &__v_132) } else { bytes2_xor_value(__v_129, __v_132, record) }; + let __v_133: G = if unconstrained { Bytes2::validate_inputs(&__v_129, &__v_132)?; Bytes2::xor(&__v_129, &__v_132) } else { bytes2_xor_value(__v_129, __v_132, record)? }; let __v_134: G = G::from_u64(0); - let __v_135: G = if unconstrained { Bytes2::xor(&__v_130, &__v_134) } else { bytes2_xor_value(__v_130, __v_134, record) }; + let __v_135: G = if unconstrained { Bytes2::validate_inputs(&__v_130, &__v_134)?; Bytes2::xor(&__v_130, &__v_134) } else { bytes2_xor_value(__v_130, __v_134, record)? }; let __v_136: G = G::from_u64(0); - let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) }; + let __v_137: G = if unconstrained { Bytes2::validate_inputs(&__v_131, &__v_136)?; Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record)? }; let __v_138: G = G::from_u64(256); let __v_139: G = (__v_138 * __v_137); let __v_140: G = (__v_135 + __v_139); @@ -15614,16 +15856,16 @@ fn aiur_fn_128( if (__v_16 != __v_147) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_147.as_canonical_u64(), msg: Some("u64_mul column 0: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_141]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_141]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_148: G = __r_arr[0]; let __v_149: G = __r_arr[1]; let __v_150: G = __r_arr[2]; let __v_151: G = G::from_u64(0); - let __v_152: G = if unconstrained { Bytes2::xor(&__v_148, &__v_151) } else { bytes2_xor_value(__v_148, __v_151, record) }; + let __v_152: G = if unconstrained { Bytes2::validate_inputs(&__v_148, &__v_151)?; Bytes2::xor(&__v_148, &__v_151) } else { bytes2_xor_value(__v_148, __v_151, record)? }; let __v_153: G = G::from_u64(0); - let __v_154: G = if unconstrained { Bytes2::xor(&__v_149, &__v_153) } else { bytes2_xor_value(__v_149, __v_153, record) }; + let __v_154: G = if unconstrained { Bytes2::validate_inputs(&__v_149, &__v_153)?; Bytes2::xor(&__v_149, &__v_153) } else { bytes2_xor_value(__v_149, __v_153, record)? }; let __v_155: G = G::from_u64(0); - let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) }; + let __v_156: G = if unconstrained { Bytes2::validate_inputs(&__v_150, &__v_155)?; Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record)? }; let __v_157: G = G::from_u64(256); let __v_158: G = (__v_157 * __v_156); let __v_159: G = (__v_154 + __v_158); @@ -15637,16 +15879,16 @@ fn aiur_fn_128( if (__v_141 != __v_166) { return Err(ExecError::AssertEqMismatch { lhs: __v_141.as_canonical_u64(), rhs: __v_166.as_canonical_u64(), msg: Some("u64_mul column 1: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_160]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_160]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; let __v_169: G = __r_arr[2]; let __v_170: G = G::from_u64(0); - let __v_171: G = if unconstrained { Bytes2::xor(&__v_167, &__v_170) } else { bytes2_xor_value(__v_167, __v_170, record) }; + let __v_171: G = if unconstrained { Bytes2::validate_inputs(&__v_167, &__v_170)?; Bytes2::xor(&__v_167, &__v_170) } else { bytes2_xor_value(__v_167, __v_170, record)? }; let __v_172: G = G::from_u64(0); - let __v_173: G = if unconstrained { Bytes2::xor(&__v_168, &__v_172) } else { bytes2_xor_value(__v_168, __v_172, record) }; + let __v_173: G = if unconstrained { Bytes2::validate_inputs(&__v_168, &__v_172)?; Bytes2::xor(&__v_168, &__v_172) } else { bytes2_xor_value(__v_168, __v_172, record)? }; let __v_174: G = G::from_u64(0); - let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_169, &__v_174)?; Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record)? }; let __v_176: G = G::from_u64(256); let __v_177: G = (__v_176 * __v_175); let __v_178: G = (__v_173 + __v_177); @@ -15660,16 +15902,16 @@ fn aiur_fn_128( if (__v_160 != __v_185) { return Err(ExecError::AssertEqMismatch { lhs: __v_160.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("u64_mul column 2: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_179]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_179]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; let __v_188: G = __r_arr[2]; let __v_189: G = G::from_u64(0); - let __v_190: G = if unconstrained { Bytes2::xor(&__v_186, &__v_189) } else { bytes2_xor_value(__v_186, __v_189, record) }; + let __v_190: G = if unconstrained { Bytes2::validate_inputs(&__v_186, &__v_189)?; Bytes2::xor(&__v_186, &__v_189) } else { bytes2_xor_value(__v_186, __v_189, record)? }; let __v_191: G = G::from_u64(0); - let __v_192: G = if unconstrained { Bytes2::xor(&__v_187, &__v_191) } else { bytes2_xor_value(__v_187, __v_191, record) }; + let __v_192: G = if unconstrained { Bytes2::validate_inputs(&__v_187, &__v_191)?; Bytes2::xor(&__v_187, &__v_191) } else { bytes2_xor_value(__v_187, __v_191, record)? }; let __v_193: G = G::from_u64(0); - let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) }; + let __v_194: G = if unconstrained { Bytes2::validate_inputs(&__v_188, &__v_193)?; Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record)? }; let __v_195: G = G::from_u64(256); let __v_196: G = (__v_195 * __v_194); let __v_197: G = (__v_192 + __v_196); @@ -15683,16 +15925,16 @@ fn aiur_fn_128( if (__v_179 != __v_204) { return Err(ExecError::AssertEqMismatch { lhs: __v_179.as_canonical_u64(), rhs: __v_204.as_canonical_u64(), msg: Some("u64_mul column 3: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_198]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_198]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_205: G = __r_arr[0]; let __v_206: G = __r_arr[1]; let __v_207: G = __r_arr[2]; let __v_208: G = G::from_u64(0); - let __v_209: G = if unconstrained { Bytes2::xor(&__v_205, &__v_208) } else { bytes2_xor_value(__v_205, __v_208, record) }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_205, &__v_208)?; Bytes2::xor(&__v_205, &__v_208) } else { bytes2_xor_value(__v_205, __v_208, record)? }; let __v_210: G = G::from_u64(0); - let __v_211: G = if unconstrained { Bytes2::xor(&__v_206, &__v_210) } else { bytes2_xor_value(__v_206, __v_210, record) }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_206, &__v_210)?; Bytes2::xor(&__v_206, &__v_210) } else { bytes2_xor_value(__v_206, __v_210, record)? }; let __v_212: G = G::from_u64(0); - let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) }; + let __v_213: G = if unconstrained { Bytes2::validate_inputs(&__v_207, &__v_212)?; Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record)? }; let __v_214: G = G::from_u64(256); let __v_215: G = (__v_214 * __v_213); let __v_216: G = (__v_211 + __v_215); @@ -15706,16 +15948,16 @@ fn aiur_fn_128( if (__v_198 != __v_223) { return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_223.as_canonical_u64(), msg: Some("u64_mul column 4: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_217]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_217]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_224: G = __r_arr[0]; let __v_225: G = __r_arr[1]; let __v_226: G = __r_arr[2]; let __v_227: G = G::from_u64(0); - let __v_228: G = if unconstrained { Bytes2::xor(&__v_224, &__v_227) } else { bytes2_xor_value(__v_224, __v_227, record) }; + let __v_228: G = if unconstrained { Bytes2::validate_inputs(&__v_224, &__v_227)?; Bytes2::xor(&__v_224, &__v_227) } else { bytes2_xor_value(__v_224, __v_227, record)? }; let __v_229: G = G::from_u64(0); - let __v_230: G = if unconstrained { Bytes2::xor(&__v_225, &__v_229) } else { bytes2_xor_value(__v_225, __v_229, record) }; + let __v_230: G = if unconstrained { Bytes2::validate_inputs(&__v_225, &__v_229)?; Bytes2::xor(&__v_225, &__v_229) } else { bytes2_xor_value(__v_225, __v_229, record)? }; let __v_231: G = G::from_u64(0); - let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) }; + let __v_232: G = if unconstrained { Bytes2::validate_inputs(&__v_226, &__v_231)?; Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record)? }; let __v_233: G = G::from_u64(256); let __v_234: G = (__v_233 * __v_232); let __v_235: G = (__v_230 + __v_234); @@ -15729,16 +15971,16 @@ fn aiur_fn_128( if (__v_217 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u64_mul column 5: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_236]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_236]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = __r_arr[2]; let __v_246: G = G::from_u64(0); - let __v_247: G = if unconstrained { Bytes2::xor(&__v_243, &__v_246) } else { bytes2_xor_value(__v_243, __v_246, record) }; + let __v_247: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_246)?; Bytes2::xor(&__v_243, &__v_246) } else { bytes2_xor_value(__v_243, __v_246, record)? }; let __v_248: G = G::from_u64(0); - let __v_249: G = if unconstrained { Bytes2::xor(&__v_244, &__v_248) } else { bytes2_xor_value(__v_244, __v_248, record) }; + let __v_249: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_248)?; Bytes2::xor(&__v_244, &__v_248) } else { bytes2_xor_value(__v_244, __v_248, record)? }; let __v_250: G = G::from_u64(0); - let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) }; + let __v_251: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_250)?; Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record)? }; let __v_252: G = G::from_u64(256); let __v_253: G = (__v_252 * __v_251); let __v_254: G = (__v_249 + __v_253); @@ -15752,16 +15994,16 @@ fn aiur_fn_128( if (__v_236 != __v_261) { return Err(ExecError::AssertEqMismatch { lhs: __v_236.as_canonical_u64(), rhs: __v_261.as_canonical_u64(), msg: Some("u64_mul column 6: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_255]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_255]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = __r_arr[2]; let __v_265: G = G::from_u64(0); - let __v_266: G = if unconstrained { Bytes2::xor(&__v_262, &__v_265) } else { bytes2_xor_value(__v_262, __v_265, record) }; + let __v_266: G = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_265)?; Bytes2::xor(&__v_262, &__v_265) } else { bytes2_xor_value(__v_262, __v_265, record)? }; let __v_267: G = G::from_u64(0); - let __v_268: G = if unconstrained { Bytes2::xor(&__v_263, &__v_267) } else { bytes2_xor_value(__v_263, __v_267, record) }; + let __v_268: G = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_267)?; Bytes2::xor(&__v_263, &__v_267) } else { bytes2_xor_value(__v_263, __v_267, record)? }; let __v_269: G = G::from_u64(0); - let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) }; + let __v_270: G = if unconstrained { Bytes2::validate_inputs(&__v_264, &__v_269)?; Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record)? }; let __v_271: G = G::from_u64(256); let __v_272: G = (__v_271 * __v_270); let __v_273: G = (__v_268 + __v_272); @@ -15775,16 +16017,16 @@ fn aiur_fn_128( if (__v_255 != __v_280) { return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_280.as_canonical_u64(), msg: Some("u64_mul column 7: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_274]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_274]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_281: G = __r_arr[0]; let __v_282: G = __r_arr[1]; let __v_283: G = __r_arr[2]; let __v_284: G = G::from_u64(0); - let __v_285: G = if unconstrained { Bytes2::xor(&__v_281, &__v_284) } else { bytes2_xor_value(__v_281, __v_284, record) }; + let __v_285: G = if unconstrained { Bytes2::validate_inputs(&__v_281, &__v_284)?; Bytes2::xor(&__v_281, &__v_284) } else { bytes2_xor_value(__v_281, __v_284, record)? }; let __v_286: G = G::from_u64(0); - let __v_287: G = if unconstrained { Bytes2::xor(&__v_282, &__v_286) } else { bytes2_xor_value(__v_282, __v_286, record) }; + let __v_287: G = if unconstrained { Bytes2::validate_inputs(&__v_282, &__v_286)?; Bytes2::xor(&__v_282, &__v_286) } else { bytes2_xor_value(__v_282, __v_286, record)? }; let __v_288: G = G::from_u64(0); - let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) }; + let __v_289: G = if unconstrained { Bytes2::validate_inputs(&__v_283, &__v_288)?; Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record)? }; let __v_290: G = G::from_u64(256); let __v_291: G = (__v_290 * __v_289); let __v_292: G = (__v_287 + __v_291); @@ -15798,16 +16040,16 @@ fn aiur_fn_128( if (__v_274 != __v_299) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_299.as_canonical_u64(), msg: Some("u64_mul column 8: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_293]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_293]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_300: G = __r_arr[0]; let __v_301: G = __r_arr[1]; let __v_302: G = __r_arr[2]; let __v_303: G = G::from_u64(0); - let __v_304: G = if unconstrained { Bytes2::xor(&__v_300, &__v_303) } else { bytes2_xor_value(__v_300, __v_303, record) }; + let __v_304: G = if unconstrained { Bytes2::validate_inputs(&__v_300, &__v_303)?; Bytes2::xor(&__v_300, &__v_303) } else { bytes2_xor_value(__v_300, __v_303, record)? }; let __v_305: G = G::from_u64(0); - let __v_306: G = if unconstrained { Bytes2::xor(&__v_301, &__v_305) } else { bytes2_xor_value(__v_301, __v_305, record) }; + let __v_306: G = if unconstrained { Bytes2::validate_inputs(&__v_301, &__v_305)?; Bytes2::xor(&__v_301, &__v_305) } else { bytes2_xor_value(__v_301, __v_305, record)? }; let __v_307: G = G::from_u64(0); - let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) }; + let __v_308: G = if unconstrained { Bytes2::validate_inputs(&__v_302, &__v_307)?; Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record)? }; let __v_309: G = G::from_u64(256); let __v_310: G = (__v_309 * __v_308); let __v_311: G = (__v_306 + __v_310); @@ -15821,16 +16063,16 @@ fn aiur_fn_128( if (__v_293 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_293.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u64_mul column 9: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_312]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_312]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_319: G = __r_arr[0]; let __v_320: G = __r_arr[1]; let __v_321: G = __r_arr[2]; let __v_322: G = G::from_u64(0); - let __v_323: G = if unconstrained { Bytes2::xor(&__v_319, &__v_322) } else { bytes2_xor_value(__v_319, __v_322, record) }; + let __v_323: G = if unconstrained { Bytes2::validate_inputs(&__v_319, &__v_322)?; Bytes2::xor(&__v_319, &__v_322) } else { bytes2_xor_value(__v_319, __v_322, record)? }; let __v_324: G = G::from_u64(0); - let __v_325: G = if unconstrained { Bytes2::xor(&__v_320, &__v_324) } else { bytes2_xor_value(__v_320, __v_324, record) }; + let __v_325: G = if unconstrained { Bytes2::validate_inputs(&__v_320, &__v_324)?; Bytes2::xor(&__v_320, &__v_324) } else { bytes2_xor_value(__v_320, __v_324, record)? }; let __v_326: G = G::from_u64(0); - let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) }; + let __v_327: G = if unconstrained { Bytes2::validate_inputs(&__v_321, &__v_326)?; Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record)? }; let __v_328: G = G::from_u64(256); let __v_329: G = (__v_328 * __v_327); let __v_330: G = (__v_325 + __v_329); @@ -15844,16 +16086,16 @@ fn aiur_fn_128( if (__v_312 != __v_337) { return Err(ExecError::AssertEqMismatch { lhs: __v_312.as_canonical_u64(), rhs: __v_337.as_canonical_u64(), msg: Some("u64_mul column 10: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_331]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_331]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_338: G = __r_arr[0]; let __v_339: G = __r_arr[1]; let __v_340: G = __r_arr[2]; let __v_341: G = G::from_u64(0); - let __v_342: G = if unconstrained { Bytes2::xor(&__v_338, &__v_341) } else { bytes2_xor_value(__v_338, __v_341, record) }; + let __v_342: G = if unconstrained { Bytes2::validate_inputs(&__v_338, &__v_341)?; Bytes2::xor(&__v_338, &__v_341) } else { bytes2_xor_value(__v_338, __v_341, record)? }; let __v_343: G = G::from_u64(0); - let __v_344: G = if unconstrained { Bytes2::xor(&__v_339, &__v_343) } else { bytes2_xor_value(__v_339, __v_343, record) }; + let __v_344: G = if unconstrained { Bytes2::validate_inputs(&__v_339, &__v_343)?; Bytes2::xor(&__v_339, &__v_343) } else { bytes2_xor_value(__v_339, __v_343, record)? }; let __v_345: G = G::from_u64(0); - let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_340, &__v_345)?; Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record)? }; let __v_347: G = G::from_u64(256); let __v_348: G = (__v_347 * __v_346); let __v_349: G = (__v_344 + __v_348); @@ -15867,16 +16109,16 @@ fn aiur_fn_128( if (__v_331 != __v_356) { return Err(ExecError::AssertEqMismatch { lhs: __v_331.as_canonical_u64(), rhs: __v_356.as_canonical_u64(), msg: Some("u64_mul column 11: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_350]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_350]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_357: G = __r_arr[0]; let __v_358: G = __r_arr[1]; let __v_359: G = __r_arr[2]; let __v_360: G = G::from_u64(0); - let __v_361: G = if unconstrained { Bytes2::xor(&__v_357, &__v_360) } else { bytes2_xor_value(__v_357, __v_360, record) }; + let __v_361: G = if unconstrained { Bytes2::validate_inputs(&__v_357, &__v_360)?; Bytes2::xor(&__v_357, &__v_360) } else { bytes2_xor_value(__v_357, __v_360, record)? }; let __v_362: G = G::from_u64(0); - let __v_363: G = if unconstrained { Bytes2::xor(&__v_358, &__v_362) } else { bytes2_xor_value(__v_358, __v_362, record) }; + let __v_363: G = if unconstrained { Bytes2::validate_inputs(&__v_358, &__v_362)?; Bytes2::xor(&__v_358, &__v_362) } else { bytes2_xor_value(__v_358, __v_362, record)? }; let __v_364: G = G::from_u64(0); - let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) }; + let __v_365: G = if unconstrained { Bytes2::validate_inputs(&__v_359, &__v_364)?; Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record)? }; let __v_366: G = G::from_u64(256); let __v_367: G = (__v_366 * __v_365); let __v_368: G = (__v_363 + __v_367); @@ -15890,16 +16132,16 @@ fn aiur_fn_128( if (__v_350 != __v_375) { return Err(ExecError::AssertEqMismatch { lhs: __v_350.as_canonical_u64(), rhs: __v_375.as_canonical_u64(), msg: Some("u64_mul column 12: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_369]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_369]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_376: G = __r_arr[0]; let __v_377: G = __r_arr[1]; let __v_378: G = __r_arr[2]; let __v_379: G = G::from_u64(0); - let __v_380: G = if unconstrained { Bytes2::xor(&__v_376, &__v_379) } else { bytes2_xor_value(__v_376, __v_379, record) }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_376, &__v_379)?; Bytes2::xor(&__v_376, &__v_379) } else { bytes2_xor_value(__v_376, __v_379, record)? }; let __v_381: G = G::from_u64(0); - let __v_382: G = if unconstrained { Bytes2::xor(&__v_377, &__v_381) } else { bytes2_xor_value(__v_377, __v_381, record) }; + let __v_382: G = if unconstrained { Bytes2::validate_inputs(&__v_377, &__v_381)?; Bytes2::xor(&__v_377, &__v_381) } else { bytes2_xor_value(__v_377, __v_381, record)? }; let __v_383: G = G::from_u64(0); - let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) }; + let __v_384: G = if unconstrained { Bytes2::validate_inputs(&__v_378, &__v_383)?; Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record)? }; let __v_385: G = G::from_u64(256); let __v_386: G = (__v_385 * __v_384); let __v_387: G = (__v_382 + __v_386); @@ -15913,16 +16155,16 @@ fn aiur_fn_128( if (__v_369 != __v_394) { return Err(ExecError::AssertEqMismatch { lhs: __v_369.as_canonical_u64(), rhs: __v_394.as_canonical_u64(), msg: Some("u64_mul column 13: split_carry hint does not recompose to the column sum".to_string()) }); } - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_388]; let __cu = true; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_388]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_395: G = __r_arr[0]; let __v_396: G = __r_arr[1]; let __v_397: G = __r_arr[2]; let __v_398: G = G::from_u64(0); - let __v_399: G = if unconstrained { Bytes2::xor(&__v_395, &__v_398) } else { bytes2_xor_value(__v_395, __v_398, record) }; + let __v_399: G = if unconstrained { Bytes2::validate_inputs(&__v_395, &__v_398)?; Bytes2::xor(&__v_395, &__v_398) } else { bytes2_xor_value(__v_395, __v_398, record)? }; let __v_400: G = G::from_u64(0); - let __v_401: G = if unconstrained { Bytes2::xor(&__v_396, &__v_400) } else { bytes2_xor_value(__v_396, __v_400, record) }; + let __v_401: G = if unconstrained { Bytes2::validate_inputs(&__v_396, &__v_400)?; Bytes2::xor(&__v_396, &__v_400) } else { bytes2_xor_value(__v_396, __v_400, record)? }; let __v_402: G = G::from_u64(0); - let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) }; + let __v_403: G = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_402)?; Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record)? }; let __v_404: G = G::from_u64(256); let __v_405: G = (__v_404 * __v_403); let __v_406: G = (__v_401 + __v_405); @@ -15935,51 +16177,86 @@ fn aiur_fn_128( if (__v_388 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u64_mul column 14: split_carry hint does not recompose to the column sum".to_string()) }); } - let __ret: [G; OUT_128] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; - record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_129] = [__v_133, __v_152, __v_171, __v_190, __v_209, __v_228, __v_247, __v_266, __v_285, __v_304, __v_323, __v_342, __v_361, __v_380, __v_399, __v_406]; + record.function_queries[129].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_129: usize = 2; -const IN_129: usize = 2; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_130: usize = 2; +const IN_130: usize = 2; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = G::from_u64(1); - let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_129] = [__v_6]; - record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); + record.checkpoint(130); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_130] = [__v_14]; + record.function_queries[130].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 0u64 => { + 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 __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_1, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_11, __v_1, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[131].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i)?; } record.function_queries[131].output_at(__i).to_array::() }, _ => aiur_fn_131(__key, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_130] = [__v_22]; + record.function_queries[130].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } }) } -const INPUT_SIZE_130: usize = 4; -const IN_130: usize = 4; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_131: usize = 4; +const IN_131: usize = 4; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(131); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -15992,219 +16269,529 @@ fn aiur_fn_130( let __v_13: G = __loaded[9]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_130] = [__v_2]; - record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_131] = [__v_2]; + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_3 + __v_15); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_13, __v_1, __v_14, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[131].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i)?; } record.function_queries[131].output_at(__i).to_array::() }, _ => aiur_fn_131(__key, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_131] = [__v_17]; + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_132: usize = 11; +const IN_132: usize = 11; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_132], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(132); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + match __v_10.as_canonical_u64() { + 0u64 => { + 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(1); - let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; - let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_25, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; - let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; - let __v_28: G = G::from_u64(1); - let __v_29: G = (__v_3 + __v_28); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; - let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_130] = [__v_30]; - record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __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_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_132] = [__v_20]; + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __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(1); + let __v_31: G = (__v_10 - __v_30); + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = { let __values: [G; 10] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_132] = [__v_33]; + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 0u64 => { + 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 __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[14].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i)?; } record.function_queries[14].output_at(__i).to_array::() }, _ => aiur_fn_14(__key, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __v_31: G = __r_arr[2]; + let __v_32: G = __r_arr[3]; + let __v_33: G = __r_arr[4]; + let __v_34: G = __r_arr[5]; + let __v_35: G = __r_arr[6]; + let __v_36: G = __r_arr[7]; + let __v_37: G = __r_arr[8]; + let __v_38: G = G::from_u64(0); + if (__v_37 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64(), msg: Some("multiply-accumulate prefix overflow".to_string()) }); + } + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(1); + let __v_41: G = (__v_10 - __v_40); + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_20, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = { let __values: [G; 10] = [__v_39, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_132] = [__v_43]; + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } }, } }) } -const INPUT_SIZE_131: usize = 18; -const IN_131: usize = 18; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_133: usize = 19; +const IN_133: usize = 19; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_131], 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]; - let __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 __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; - let __v_18: G = __loaded[0]; - let __v_19: G = __loaded[1]; - let __v_20: G = __loaded[2]; - let __v_21: G = __loaded[3]; - let __v_22: G = __loaded[4]; - let __v_23: G = __loaded[5]; - let __v_24: G = __loaded[6]; - let __v_25: G = __loaded[7]; - let __v_26: G = __loaded[8]; - let __v_27: G = __loaded[9]; - match __v_18.as_canonical_u64() { + record.checkpoint(133); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - match __v_28.as_canonical_u64() { + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __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]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_29, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_133] = [__v_30]; + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; + let __v_29: G = __loaded[0]; + let __v_30: G = __loaded[1]; + let __v_31: G = __loaded[2]; + let __v_32: G = __loaded[3]; + let __v_33: G = __loaded[4]; + let __v_34: G = __loaded[5]; + let __v_35: G = __loaded[6]; + let __v_36: G = __loaded[7]; + let __v_37: G = __loaded[8]; + let __v_38: G = __loaded[9]; + match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_131] = [__v_17]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __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]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_39, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __ret: [G; OUT_133] = [__v_40]; + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } }; - let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_131] = [__v_29]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = __r_arr[9]; + let __v_49: G = __r_arr[10]; + let __v_50: G = __r_arr[11]; + let __v_51: G = __r_arr[12]; + let __v_52: G = __r_arr[13]; + let __v_53: G = __r_arr[14]; + let __v_54: G = __r_arr[15]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[14].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i)?; } record.function_queries[14].output_at(__i).to_array::() }, _ => aiur_fn_14(__key, 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 __v_58: G = __r_arr[3]; + let __v_59: G = __r_arr[4]; + let __v_60: G = __r_arr[5]; + let __v_61: G = __r_arr[6]; + let __v_62: G = __r_arr[7]; + let __v_63: G = __r_arr[8]; + match __v_63.as_canonical_u64() { + 0u64 => { + let __mc_out___mc_0: [G; 9] = '__mc_0: { match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[14].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i)?; } record.function_queries[14].output_at(__i).to_array::() }, _ => aiur_fn_14(__key, 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]; + break '__mc_0 [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; + }, + 1u64 => { + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, 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]; + break '__mc_0 [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, +} + }; + let __v_64: G = __mc_out___mc_0[0]; + let __v_65: G = __mc_out___mc_0[1]; + let __v_66: G = __mc_out___mc_0[2]; + let __v_67: G = __mc_out___mc_0[3]; + let __v_68: G = __mc_out___mc_0[4]; + let __v_69: G = __mc_out___mc_0[5]; + let __v_70: G = __mc_out___mc_0[6]; + let __v_71: G = __mc_out___mc_0[7]; + let __v_72: G = __mc_out___mc_0[8]; + let __v_73: G = G::from_u64(0); + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28, __v_38, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = { let __values: [G; 10] = [__v_73, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_133] = [__v_75]; + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, 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 __mc_out___mc_1: [G; 9] = '__mc_1: { match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[14].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i)?; } record.function_queries[14].output_at(__i).to_array::() }, _ => aiur_fn_14(__key, 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]; + break '__mc_1 [__v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; + }, + 1u64 => { + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, 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]; + break '__mc_1 [__v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, +} + }; + let __v_73: G = __mc_out___mc_1[0]; + let __v_74: G = __mc_out___mc_1[1]; + let __v_75: G = __mc_out___mc_1[2]; + let __v_76: G = __mc_out___mc_1[3]; + let __v_77: G = __mc_out___mc_1[4]; + let __v_78: G = __mc_out___mc_1[5]; + let __v_79: G = __mc_out___mc_1[6]; + let __v_80: G = __mc_out___mc_1[7]; + let __v_81: G = __mc_out___mc_1[8]; + let __v_82: G = G::from_u64(0); + if (__v_72 != __v_82) { + return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_82.as_canonical_u64(), msg: Some("multiplication row carry overflow".to_string()) }); + } + let __v_83: G = G::from_u64(0); + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28, __v_38, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = { let __values: [G; 10] = [__v_83, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_133] = [__v_85]; + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); + }, + } }, _ => { - return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); }, } }, - 0u64 => { - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; - let __v_28: G = __r_arr[0]; - let __v_29: G = __r_arr[1]; - let __v_30: G = __r_arr[2]; - let __v_31: G = __r_arr[3]; - let __v_32: G = __r_arr[4]; - let __v_33: G = __r_arr[5]; - let __v_34: G = __r_arr[6]; - let __v_35: G = __r_arr[7]; - let __v_36: G = __r_arr[8]; - let __v_37: G = __r_arr[9]; - let __v_38: G = __r_arr[10]; - let __v_39: G = __r_arr[11]; - let __v_40: G = __r_arr[12]; - let __v_41: G = __r_arr[13]; - let __v_42: G = __r_arr[14]; - let __v_43: G = __r_arr[15]; - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; - let __v_44: G = __r_arr[0]; - let __v_45: G = __r_arr[1]; - let __v_46: G = __r_arr[2]; - let __v_47: G = __r_arr[3]; - let __v_48: G = __r_arr[4]; - let __v_49: G = __r_arr[5]; - let __v_50: G = __r_arr[6]; - let __v_51: G = __r_arr[7]; - let __v_52: G = __r_arr[8]; - let __v_53: G = G::from_u64(0); - let __v_54: G = G::from_u64(0); - let __v_55: G = G::from_u64(0); - let __v_56: G = G::from_u64(0); - let __v_57: G = G::from_u64(0); - let __v_58: G = G::from_u64(0); - let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[14].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i); } let __ret: [G; OUT_14] = unsafe { *(record.function_queries[14].output_at(__i).as_ptr() as *const [G; OUT_14]) }; __ret }, _ => aiur_fn_14(__args, record, io_buffer, __cu)? } }; - let __v_60: G = __r_arr[0]; - let __v_61: G = __r_arr[1]; - let __v_62: G = __r_arr[2]; - let __v_63: G = __r_arr[3]; - let __v_64: G = __r_arr[4]; - let __v_65: G = __r_arr[5]; - let __v_66: G = __r_arr[6]; - let __v_67: G = __r_arr[7]; - let __v_68: G = __r_arr[8]; - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } }; - let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_27, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; - let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_131] = [__v_70]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }, _ => { - return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); }, } }) } -const INPUT_SIZE_132: usize = 2; -const IN_132: usize = 2; -const OUT_132: usize = 1; -fn aiur_fn_132( - inp: [G; IN_132], +const INPUT_SIZE_134: usize = 17; +const IN_134: usize = 17; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_132], 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]; - match __v_1.as_canonical_u64() { + record.checkpoint(134); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 1u64 => { + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 10] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_134] = [__v_30]; + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 0u64 => { + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_28, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_134] = [__v_32]; + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, 0u64 => { - let __ret: [G; OUT_132] = [__v_0]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = __r_arr[3]; + let __v_31: G = __r_arr[4]; + let __v_32: G = __r_arr[5]; + let __v_33: G = __r_arr[6]; + let __v_34: G = __r_arr[7]; + let __v_35: G = __r_arr[8]; + let __v_36: G = __r_arr[9]; + let __v_37: G = __r_arr[10]; + let __v_38: G = __r_arr[11]; + let __v_39: G = __r_arr[12]; + let __v_40: G = __r_arr[13]; + let __v_41: G = __r_arr[14]; + let __v_42: G = __r_arr[15]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[14].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[14].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[14].bump_multiplicity(__i)?; } record.function_queries[14].output_at(__i).to_array::() }, _ => aiur_fn_14(__key, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __v_45: G = __r_arr[2]; + let __v_46: G = __r_arr[3]; + let __v_47: G = __r_arr[4]; + let __v_48: G = __r_arr[5]; + let __v_49: G = __r_arr[6]; + let __v_50: G = __r_arr[7]; + let __v_51: G = __r_arr[8]; + match __v_51.as_canonical_u64() { + 0u64 => { + let __v_52: G = G::from_u64(0); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = { let __values: [G; 10] = [__v_52, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_134] = [__v_54]; + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, 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 = G::from_u64(0); + if (__v_60 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_61.as_canonical_u64(), msg: Some("multiplication row carry overflow".to_string()) }); + } + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = { let __values: [G; 10] = [__v_62, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_134] = [__v_64]; + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_51.as_canonical_u64())); + }, + } }, _ => { - let __v_2: G = G::from_u64(0); - let __v_3: G = G::from_u64(0); - let __v_4: G = G::from_u64(0); - let __v_5: G = G::from_u64(0); - let __v_6: G = G::from_u64(0); - let __v_7: G = G::from_u64(0); - let __v_8: G = G::from_u64(0); - let __v_9: G = G::from_u64(0); - let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = G::from_u64(1); - let __v_13: G = (__v_1 - __v_12); - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; - let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_132] = [__v_14]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); }, } }) } -const INPUT_SIZE_133: usize = 1; -const IN_133: usize = 1; -const OUT_133: usize = 1; -fn aiur_fn_133( - inp: [G; IN_133], +const INPUT_SIZE_135: usize = 1; +const IN_135: usize = 1; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_133], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + record.checkpoint(135); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16218,79 +16805,80 @@ fn aiur_fn_133( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_133] = [__v_12]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_135] = [__v_12]; + record.function_queries[135].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_133] = [__v_12]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_135] = [__v_12]; + record.function_queries[135].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_134: usize = 2; -const IN_134: usize = 2; -const OUT_134: usize = 2; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_136: usize = 2; +const IN_136: usize = 2; +const OUT_136: usize = 2; +fn aiur_fn_136( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], 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]; + record.checkpoint(136); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?; let __v_2: G = __bu_qr.0; let __v_3: G = __bu_qr.1; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; if (__v_10 != __v_11) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) }); } - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); if (__v_13 != __v_14) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("div/mod hint: division by zero must yield a zero quotient".to_string()) }); } - let __ret: [G; OUT_134] = [__v_5, __v_7]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_136] = [__v_5, __v_7]; + record.function_queries[136].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) }); } - let __ret: [G; OUT_134] = [__v_5, __v_7]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_136] = [__v_5, __v_7]; + record.function_queries[136].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16300,75 +16888,78 @@ fn aiur_fn_134( }) } -const INPUT_SIZE_135: usize = 2; -const IN_135: usize = 2; -const OUT_135: usize = 1; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_137: usize = 2; +const IN_137: usize = 2; +const OUT_137: usize = 1; +fn aiur_fn_137( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], 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]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + record.checkpoint(137); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_135] = [__v_2]; - record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_137] = [__v_2]; + record.function_queries[137].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_136: usize = 2; -const IN_136: usize = 2; -const OUT_136: usize = 1; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_138: usize = 2; +const IN_138: usize = 2; +const OUT_138: usize = 1; +fn aiur_fn_138( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + record.checkpoint(138); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __ret: [G; OUT_136] = [__v_3]; - record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_138] = [__v_3]; + record.function_queries[138].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_137: usize = 2; -const IN_137: usize = 2; -const OUT_137: usize = 1; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_139: usize = 2; +const IN_139: usize = 2; +const OUT_139: usize = 1; +fn aiur_fn_139( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(139); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_137] = [__v_0]; - record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_139] = [__v_0]; + record.function_queries[139].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[139].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i)?; } record.function_queries[139].output_at(__i).to_array::() }, _ => aiur_fn_139(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_137] = [__v_4]; - record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_139] = [__v_4]; + record.function_queries[139].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16378,19 +16969,20 @@ fn aiur_fn_137( }) } -const INPUT_SIZE_138: usize = 2; -const IN_138: usize = 2; -const OUT_138: usize = 1; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_140: usize = 2; +const IN_140: usize = 2; +const OUT_140: usize = 1; +fn aiur_fn_140( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { +) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(140); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { @@ -16405,10 +16997,10 @@ fn aiur_fn_138( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_138] = [__v_15]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_140] = [__v_15]; + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -16423,32 +17015,32 @@ fn aiur_fn_138( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_138] = [__v_21]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_140] = [__v_21]; + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_138] = [__v_23]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_140] = [__v_23]; + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16463,139 +17055,143 @@ fn aiur_fn_138( }) } -const INPUT_SIZE_139: usize = 16; -const IN_139: usize = 16; -const OUT_139: usize = 8; -fn aiur_fn_139( - inp: [G; IN_139], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_139], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - 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 = if unconstrained { Bytes2::and(&__v_0, &__v_8) } else { bytes2_and_value(__v_0, __v_8, record) }; - let __v_17: G = if unconstrained { Bytes2::and(&__v_1, &__v_9) } else { bytes2_and_value(__v_1, __v_9, record) }; - let __v_18: G = if unconstrained { Bytes2::and(&__v_2, &__v_10) } else { bytes2_and_value(__v_2, __v_10, record) }; - let __v_19: G = if unconstrained { Bytes2::and(&__v_3, &__v_11) } else { bytes2_and_value(__v_3, __v_11, record) }; - let __v_20: G = if unconstrained { Bytes2::and(&__v_4, &__v_12) } else { bytes2_and_value(__v_4, __v_12, record) }; - let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) }; - let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; - let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_139] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }) -} - -const INPUT_SIZE_140: usize = 16; -const IN_140: usize = 16; -const OUT_140: usize = 8; -fn aiur_fn_140( - inp: [G; IN_140], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_140], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - 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 = if unconstrained { Bytes2::or(&__v_0, &__v_8) } else { bytes2_or_value(__v_0, __v_8, record) }; - let __v_17: G = if unconstrained { Bytes2::or(&__v_1, &__v_9) } else { bytes2_or_value(__v_1, __v_9, record) }; - let __v_18: G = if unconstrained { Bytes2::or(&__v_2, &__v_10) } else { bytes2_or_value(__v_2, __v_10, record) }; - let __v_19: G = if unconstrained { Bytes2::or(&__v_3, &__v_11) } else { bytes2_or_value(__v_3, __v_11, record) }; - let __v_20: G = if unconstrained { Bytes2::or(&__v_4, &__v_12) } else { bytes2_or_value(__v_4, __v_12, record) }; - let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) }; - let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; - let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; - let __ret: [G; OUT_140] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }) -} - const INPUT_SIZE_141: usize = 16; const IN_141: usize = 16; const OUT_141: usize = 8; fn aiur_fn_141( - inp: [G; IN_141], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __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 = if unconstrained { Bytes2::xor(&__v_0, &__v_8) } else { bytes2_xor_value(__v_0, __v_8, record) }; - let __v_17: G = if unconstrained { Bytes2::xor(&__v_1, &__v_9) } else { bytes2_xor_value(__v_1, __v_9, record) }; - let __v_18: G = if unconstrained { Bytes2::xor(&__v_2, &__v_10) } else { bytes2_xor_value(__v_2, __v_10, record) }; - let __v_19: G = if unconstrained { Bytes2::xor(&__v_3, &__v_11) } else { bytes2_xor_value(__v_3, __v_11, record) }; - let __v_20: G = if unconstrained { Bytes2::xor(&__v_4, &__v_12) } else { bytes2_xor_value(__v_4, __v_12, record) }; - let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) }; - let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; - let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; + record.checkpoint(141); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::and(&__v_0, &__v_8) } else { bytes2_and_value(__v_0, __v_8, record)? }; + let __v_17: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_9)?; Bytes2::and(&__v_1, &__v_9) } else { bytes2_and_value(__v_1, __v_9, record)? }; + let __v_18: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_10)?; Bytes2::and(&__v_2, &__v_10) } else { bytes2_and_value(__v_2, __v_10, record)? }; + let __v_19: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_11)?; Bytes2::and(&__v_3, &__v_11) } else { bytes2_and_value(__v_3, __v_11, record)? }; + let __v_20: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_12)?; Bytes2::and(&__v_4, &__v_12) } else { bytes2_and_value(__v_4, __v_12, record)? }; + let __v_21: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_13)?; Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record)? }; + let __v_22: G = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_14)?; Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record)? }; + let __v_23: G = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_15)?; Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record)? }; let __ret: [G; OUT_141] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; - record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[141].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_142: usize = 2; -const IN_142: usize = 2; -const OUT_142: usize = 1; +const INPUT_SIZE_142: usize = 16; +const IN_142: usize = 16; +const OUT_142: usize = 8; fn aiur_fn_142( - inp: [G; IN_142], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(142); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::or(&__v_0, &__v_8) } else { bytes2_or_value(__v_0, __v_8, record)? }; + let __v_17: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_9)?; Bytes2::or(&__v_1, &__v_9) } else { bytes2_or_value(__v_1, __v_9, record)? }; + let __v_18: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_10)?; Bytes2::or(&__v_2, &__v_10) } else { bytes2_or_value(__v_2, __v_10, record)? }; + let __v_19: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_11)?; Bytes2::or(&__v_3, &__v_11) } else { bytes2_or_value(__v_3, __v_11, record)? }; + let __v_20: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_12)?; Bytes2::or(&__v_4, &__v_12) } else { bytes2_or_value(__v_4, __v_12, record)? }; + let __v_21: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_13)?; Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record)? }; + let __v_22: G = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_14)?; Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record)? }; + let __v_23: G = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_15)?; Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record)? }; + let __ret: [G; OUT_142] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[142].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }) +} + +const INPUT_SIZE_143: usize = 16; +const IN_143: usize = 16; +const OUT_143: usize = 8; +fn aiur_fn_143( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_143], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(143); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::xor(&__v_0, &__v_8) } else { bytes2_xor_value(__v_0, __v_8, record)? }; + let __v_17: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_9)?; Bytes2::xor(&__v_1, &__v_9) } else { bytes2_xor_value(__v_1, __v_9, record)? }; + let __v_18: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_10)?; Bytes2::xor(&__v_2, &__v_10) } else { bytes2_xor_value(__v_2, __v_10, record)? }; + let __v_19: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_11)?; Bytes2::xor(&__v_3, &__v_11) } else { bytes2_xor_value(__v_3, __v_11, record)? }; + let __v_20: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_12)?; Bytes2::xor(&__v_4, &__v_12) } else { bytes2_xor_value(__v_4, __v_12, record)? }; + let __v_21: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_13)?; Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record)? }; + let __v_22: G = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_14)?; Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record)? }; + let __v_23: G = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_15)?; Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record)? }; + let __ret: [G; OUT_143] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !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: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_144], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(144); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16610,13 +17206,13 @@ fn aiur_fn_142( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_142] = [__v_14]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_144] = [__v_14]; + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -16631,14 +17227,14 @@ fn aiur_fn_142( 1u64 => { let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_142] = [__v_24]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_144] = [__v_24]; + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[141].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i)?; } record.function_queries[141].output_at(__i).to_array::() }, _ => aiur_fn_141(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16647,11 +17243,11 @@ fn aiur_fn_142( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_142] = [__v_32]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_144] = [__v_32]; + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16666,19 +17262,20 @@ fn aiur_fn_142( }) } -const INPUT_SIZE_143: usize = 2; -const IN_143: usize = 2; -const OUT_143: usize = 1; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_145: usize = 2; +const IN_145: usize = 2; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], 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]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(145); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16691,12 +17288,12 @@ fn aiur_fn_143( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_143] = [__v_1]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_145] = [__v_1]; + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -16709,13 +17306,13 @@ fn aiur_fn_143( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_143] = [__v_0]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_145] = [__v_0]; + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16724,11 +17321,11 @@ fn aiur_fn_143( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[145].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[145].bump_multiplicity(__i)?; } record.function_queries[145].output_at(__i).to_array::() }, _ => aiur_fn_145(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_143] = [__v_32]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_145] = [__v_32]; + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16743,19 +17340,20 @@ fn aiur_fn_143( }) } -const INPUT_SIZE_144: usize = 2; -const IN_144: usize = 2; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], +const INPUT_SIZE_146: usize = 2; +const IN_146: usize = 2; +const OUT_146: usize = 1; +fn aiur_fn_146( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_144], 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]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(146); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16768,12 +17366,12 @@ fn aiur_fn_144( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_144] = [__v_1]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_146] = [__v_1]; + record.function_queries[146].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -16786,13 +17384,13 @@ fn aiur_fn_144( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_144] = [__v_0]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_146] = [__v_0]; + record.function_queries[146].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; @@ -16801,11 +17399,11 @@ fn aiur_fn_144( let __v_28: G = __r_arr[5]; let __v_29: G = __r_arr[6]; let __v_30: G = __r_arr[7]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[146].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[146].bump_multiplicity(__i)?; } record.function_queries[146].output_at(__i).to_array::() }, _ => aiur_fn_146(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_144] = [__v_32]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_146] = [__v_32]; + record.function_queries[146].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16820,18 +17418,19 @@ fn aiur_fn_144( }) } -const INPUT_SIZE_145: usize = 2; -const IN_145: usize = 2; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], +const INPUT_SIZE_147: usize = 2; +const IN_147: usize = 2; +const OUT_147: usize = 1; +fn aiur_fn_147( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], 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]; + record.checkpoint(147); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(0); @@ -16843,30 +17442,31 @@ fn aiur_fn_145( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_145] = [__v_16]; - record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_147] = [__v_16]; + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_146: usize = 2; -const IN_146: usize = 2; -const OUT_146: usize = 1; -fn aiur_fn_146( - inp: [G; IN_146], +const INPUT_SIZE_148: usize = 2; +const IN_148: usize = 2; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_146], ExecError> { +) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(148); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(0); @@ -16878,28 +17478,29 @@ fn aiur_fn_146( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_146] = [__v_16]; - record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_148] = [__v_16]; + record.function_queries[148].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_147: usize = 0; -const IN_147: usize = 0; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_149: usize = 0; +const IN_149: usize = 0; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_147], ExecError> { +) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(149); let __v_0: G = G::from_u64(80); let __v_1: G = G::from_u64(229); let __v_2: G = G::from_u64(214); @@ -16932,23 +17533,24 @@ fn aiur_fn_147( let __v_29: G = G::from_u64(192); let __v_30: G = G::from_u64(12); let __v_31: G = G::from_u64(140); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_147] = [__v_32]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_149] = [__v_32]; + record.function_queries[149].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 0; -const IN_148: usize = 0; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_150: usize = 0; +const IN_150: usize = 0; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_148], ExecError> { +) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(150); let __v_0: G = G::from_u64(140); let __v_1: G = G::from_u64(9); let __v_2: G = G::from_u64(202); @@ -16981,23 +17583,24 @@ fn aiur_fn_148( let __v_29: G = G::from_u64(59); let __v_30: G = G::from_u64(43); let __v_31: G = G::from_u64(12); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_148] = [__v_32]; - record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_150] = [__v_32]; + record.function_queries[150].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_149: usize = 0; -const IN_149: usize = 0; -const OUT_149: usize = 1; -fn aiur_fn_149( - inp: [G; IN_149], +const INPUT_SIZE_151: usize = 0; +const IN_151: usize = 0; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_149], ExecError> { +) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(151); let __v_0: G = G::from_u64(252); let __v_1: G = G::from_u64(233); let __v_2: G = G::from_u64(22); @@ -17030,23 +17633,24 @@ fn aiur_fn_149( let __v_29: G = G::from_u64(7); let __v_30: G = G::from_u64(214); let __v_31: G = G::from_u64(78); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_149] = [__v_32]; - record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_151] = [__v_32]; + record.function_queries[151].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_150: usize = 0; -const IN_150: usize = 0; -const OUT_150: usize = 1; -fn aiur_fn_150( - inp: [G; IN_150], +const INPUT_SIZE_152: usize = 0; +const IN_152: usize = 0; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_150], ExecError> { +) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(152); let __v_0: G = G::from_u64(72); let __v_1: G = G::from_u64(120); let __v_2: G = G::from_u64(107); @@ -17079,23 +17683,24 @@ fn aiur_fn_150( let __v_29: G = G::from_u64(161); let __v_30: G = G::from_u64(83); let __v_31: G = G::from_u64(155); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_150] = [__v_32]; - record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_152] = [__v_32]; + record.function_queries[152].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_151: usize = 0; -const IN_151: usize = 0; -const OUT_151: usize = 1; -fn aiur_fn_151( - inp: [G; IN_151], +const INPUT_SIZE_153: usize = 0; +const IN_153: usize = 0; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_151], ExecError> { +) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(153); let __v_0: G = G::from_u64(207); let __v_1: G = G::from_u64(201); let __v_2: G = G::from_u64(52); @@ -17128,23 +17733,24 @@ fn aiur_fn_151( let __v_29: G = G::from_u64(252); let __v_30: G = G::from_u64(14); let __v_31: G = G::from_u64(80); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_151] = [__v_32]; - record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_153] = [__v_32]; + record.function_queries[153].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_152: usize = 0; -const IN_152: usize = 0; -const OUT_152: usize = 1; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_154: usize = 0; +const IN_154: usize = 0; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], ExecError> { +) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(154); let __v_0: G = G::from_u64(30); let __v_1: G = G::from_u64(96); let __v_2: G = G::from_u64(189); @@ -17177,23 +17783,24 @@ fn aiur_fn_152( let __v_29: G = G::from_u64(13); let __v_30: G = G::from_u64(185); let __v_31: G = G::from_u64(100); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_152] = [__v_32]; - record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_154] = [__v_32]; + record.function_queries[154].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_153: usize = 0; -const IN_153: usize = 0; -const OUT_153: usize = 1; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_155: usize = 0; +const IN_155: usize = 0; +const OUT_155: usize = 1; +fn aiur_fn_155( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_153], ExecError> { +) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(155); let __v_0: G = G::from_u64(13); let __v_1: G = G::from_u64(116); let __v_2: G = G::from_u64(186); @@ -17226,23 +17833,24 @@ fn aiur_fn_153( let __v_29: G = G::from_u64(223); let __v_30: G = G::from_u64(24); let __v_31: G = G::from_u64(77); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_32]; - record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_155] = [__v_32]; + record.function_queries[155].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_154: usize = 0; -const IN_154: usize = 0; -const OUT_154: usize = 1; -fn aiur_fn_154( - inp: [G; IN_154], +const INPUT_SIZE_156: usize = 0; +const IN_156: usize = 0; +const OUT_156: usize = 1; +fn aiur_fn_156( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], ExecError> { +) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(156); let __v_0: G = G::from_u64(197); let __v_1: G = G::from_u64(190); let __v_2: G = G::from_u64(246); @@ -17275,23 +17883,24 @@ fn aiur_fn_154( let __v_29: G = G::from_u64(19); let __v_30: G = G::from_u64(197); let __v_31: G = G::from_u64(90); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_154] = [__v_32]; - record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_156] = [__v_32]; + record.function_queries[156].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 0; -const IN_155: usize = 0; -const OUT_155: usize = 1; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_157: usize = 0; +const IN_157: usize = 0; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_155], ExecError> { +) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(157); let __v_0: G = G::from_u64(188); let __v_1: G = G::from_u64(97); let __v_2: G = G::from_u64(193); @@ -17324,23 +17933,24 @@ fn aiur_fn_155( let __v_29: G = G::from_u64(176); let __v_30: G = G::from_u64(75); let __v_31: G = G::from_u64(162); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_155] = [__v_32]; - record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_157] = [__v_32]; + record.function_queries[157].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_156: usize = 0; -const IN_156: usize = 0; -const OUT_156: usize = 1; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_158: usize = 0; +const IN_158: usize = 0; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], ExecError> { +) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(158); let __v_0: G = G::from_u64(212); let __v_1: G = G::from_u64(53); let __v_2: G = G::from_u64(161); @@ -17373,23 +17983,24 @@ fn aiur_fn_156( let __v_29: G = G::from_u64(79); let __v_30: G = G::from_u64(114); let __v_31: G = G::from_u64(39); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_156] = [__v_32]; - record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_158] = [__v_32]; + record.function_queries[158].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 0; -const IN_157: usize = 0; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_159: usize = 0; +const IN_159: usize = 0; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(159); let __v_0: G = G::from_u64(62); let __v_1: G = G::from_u64(19); let __v_2: G = G::from_u64(252); @@ -17422,23 +18033,24 @@ fn aiur_fn_157( let __v_29: G = G::from_u64(151); let __v_30: G = G::from_u64(203); let __v_31: G = G::from_u64(14); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_157] = [__v_32]; - record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_159] = [__v_32]; + record.function_queries[159].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_158: usize = 0; -const IN_158: usize = 0; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_160: usize = 0; +const IN_160: usize = 0; +const OUT_160: usize = 1; +fn aiur_fn_160( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(160); let __v_0: G = G::from_u64(153); let __v_1: G = G::from_u64(112); let __v_2: G = G::from_u64(244); @@ -17471,23 +18083,24 @@ fn aiur_fn_158( let __v_29: G = G::from_u64(21); let __v_30: G = G::from_u64(241); let __v_31: G = G::from_u64(156); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_158] = [__v_32]; - record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_160] = [__v_32]; + record.function_queries[160].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_159: usize = 0; -const IN_159: usize = 0; -const OUT_159: usize = 1; -fn aiur_fn_159( - inp: [G; IN_159], +const INPUT_SIZE_161: usize = 0; +const IN_161: usize = 0; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], ExecError> { +) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(161); let __v_0: G = G::from_u64(134); let __v_1: G = G::from_u64(127); let __v_2: G = G::from_u64(142); @@ -17520,23 +18133,24 @@ fn aiur_fn_159( let __v_29: G = G::from_u64(110); let __v_30: G = G::from_u64(70); let __v_31: G = G::from_u64(246); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_159] = [__v_32]; - record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_161] = [__v_32]; + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 0; -const IN_160: usize = 0; -const OUT_160: usize = 1; -fn aiur_fn_160( - inp: [G; IN_160], +const INPUT_SIZE_162: usize = 0; +const IN_162: usize = 0; +const OUT_162: usize = 1; +fn aiur_fn_162( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_160], ExecError> { +) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(162); let __v_0: G = G::from_u64(33); let __v_1: G = G::from_u64(212); let __v_2: G = G::from_u64(218); @@ -17569,23 +18183,24 @@ fn aiur_fn_160( let __v_29: G = G::from_u64(130); let __v_30: G = G::from_u64(85); let __v_31: G = G::from_u64(68); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_160] = [__v_32]; - record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_162] = [__v_32]; + record.function_queries[162].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_161: usize = 0; -const IN_161: usize = 0; -const OUT_161: usize = 1; -fn aiur_fn_161( - inp: [G; IN_161], +const INPUT_SIZE_163: usize = 0; +const IN_163: usize = 0; +const OUT_163: usize = 1; +fn aiur_fn_163( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_161], ExecError> { +) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(163); let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(133); let __v_2: G = G::from_u64(153); @@ -17618,23 +18233,24 @@ fn aiur_fn_161( let __v_29: G = G::from_u64(34); let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(134); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_161] = [__v_32]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_163] = [__v_32]; + record.function_queries[163].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_162: usize = 0; -const IN_162: usize = 0; -const OUT_162: usize = 1; -fn aiur_fn_162( - inp: [G; IN_162], +const INPUT_SIZE_164: usize = 0; +const IN_164: usize = 0; +const OUT_164: usize = 1; +fn aiur_fn_164( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_162], ExecError> { +) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(164); let __v_0: G = G::from_u64(249); let __v_1: G = G::from_u64(172); let __v_2: G = G::from_u64(146); @@ -17667,23 +18283,24 @@ fn aiur_fn_162( let __v_29: G = G::from_u64(73); let __v_30: G = G::from_u64(84); let __v_31: G = G::from_u64(60); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_162] = [__v_32]; - record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_164] = [__v_32]; + record.function_queries[164].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_163: usize = 0; -const IN_163: usize = 0; -const OUT_163: usize = 1; -fn aiur_fn_163( - inp: [G; IN_163], +const INPUT_SIZE_165: usize = 0; +const IN_165: usize = 0; +const OUT_165: usize = 1; +fn aiur_fn_165( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_163], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(165); let __v_0: G = G::from_u64(223); let __v_1: G = G::from_u64(56); let __v_2: G = G::from_u64(53); @@ -17716,23 +18333,24 @@ fn aiur_fn_163( let __v_29: G = G::from_u64(171); let __v_30: G = G::from_u64(235); let __v_31: G = G::from_u64(9); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_163] = [__v_32]; - record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_165] = [__v_32]; + record.function_queries[165].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_164: usize = 0; -const IN_164: usize = 0; -const OUT_164: usize = 1; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_166: usize = 0; +const IN_166: usize = 0; +const OUT_166: usize = 1; +fn aiur_fn_166( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(166); let __v_0: G = G::from_u64(243); let __v_1: G = G::from_u64(141); let __v_2: G = G::from_u64(79); @@ -17765,23 +18383,24 @@ fn aiur_fn_164( let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(22); let __v_31: G = G::from_u64(170); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_164] = [__v_32]; - record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_166] = [__v_32]; + record.function_queries[166].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_165: usize = 0; -const IN_165: usize = 0; -const OUT_165: usize = 1; -fn aiur_fn_165( - inp: [G; IN_165], +const INPUT_SIZE_167: usize = 0; +const IN_167: usize = 0; +const OUT_167: usize = 1; +fn aiur_fn_167( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(167); let __v_0: G = G::from_u64(104); let __v_1: G = G::from_u64(246); let __v_2: G = G::from_u64(30); @@ -17814,23 +18433,24 @@ fn aiur_fn_165( let __v_29: G = G::from_u64(149); let __v_30: G = G::from_u64(230); let __v_31: G = G::from_u64(253); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_165] = [__v_32]; - record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_167] = [__v_32]; + record.function_queries[167].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_166: usize = 0; -const IN_166: usize = 0; -const OUT_166: usize = 1; -fn aiur_fn_166( - inp: [G; IN_166], +const INPUT_SIZE_168: usize = 0; +const IN_168: usize = 0; +const OUT_168: usize = 1; +fn aiur_fn_168( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_166], ExecError> { +) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(168); let __v_0: G = G::from_u64(173); let __v_1: G = G::from_u64(71); let __v_2: G = G::from_u64(242); @@ -17863,23 +18483,24 @@ fn aiur_fn_166( let __v_29: G = G::from_u64(180); let __v_30: G = G::from_u64(127); let __v_31: G = G::from_u64(3); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_166] = [__v_32]; - record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_168] = [__v_32]; + record.function_queries[168].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_167: usize = 0; -const IN_167: usize = 0; -const OUT_167: usize = 1; -fn aiur_fn_167( - inp: [G; IN_167], +const INPUT_SIZE_169: usize = 0; +const IN_169: usize = 0; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_167], ExecError> { +) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(169); let __v_0: G = G::from_u64(246); let __v_1: G = G::from_u64(235); let __v_2: G = G::from_u64(116); @@ -17912,23 +18533,24 @@ fn aiur_fn_167( let __v_29: G = G::from_u64(7); let __v_30: G = G::from_u64(13); let __v_31: G = G::from_u64(123); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_167] = [__v_32]; - record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_169] = [__v_32]; + record.function_queries[169].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 0; -const IN_168: usize = 0; -const OUT_168: usize = 1; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_170: usize = 0; +const IN_170: usize = 0; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_168], ExecError> { +) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(170); let __v_0: G = G::from_u64(35); let __v_1: G = G::from_u64(23); let __v_2: G = G::from_u64(54); @@ -17961,23 +18583,24 @@ fn aiur_fn_168( let __v_29: G = G::from_u64(122); let __v_30: G = G::from_u64(211); let __v_31: G = G::from_u64(231); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_168] = [__v_32]; - record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_170] = [__v_32]; + record.function_queries[170].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_169: usize = 0; -const IN_169: usize = 0; -const OUT_169: usize = 1; -fn aiur_fn_169( - inp: [G; IN_169], +const INPUT_SIZE_171: usize = 0; +const IN_171: usize = 0; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_169], ExecError> { +) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(171); let __v_0: G = G::from_u64(143); let __v_1: G = G::from_u64(71); let __v_2: G = G::from_u64(92); @@ -18010,23 +18633,24 @@ fn aiur_fn_169( let __v_29: G = G::from_u64(128); let __v_30: G = G::from_u64(111); let __v_31: G = G::from_u64(59); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_169] = [__v_32]; - record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_171] = [__v_32]; + record.function_queries[171].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_170: usize = 0; -const IN_170: usize = 0; -const OUT_170: usize = 1; -fn aiur_fn_170( - inp: [G; IN_170], +const INPUT_SIZE_172: usize = 0; +const IN_172: usize = 0; +const OUT_172: usize = 1; +fn aiur_fn_172( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_170], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(172); let __v_0: G = G::from_u64(143); let __v_1: G = G::from_u64(60); let __v_2: G = G::from_u64(28); @@ -18059,23 +18683,24 @@ fn aiur_fn_170( let __v_29: G = G::from_u64(98); let __v_30: G = G::from_u64(44); let __v_31: G = G::from_u64(99); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_170] = [__v_32]; - record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_172] = [__v_32]; + record.function_queries[172].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_171: usize = 0; -const IN_171: usize = 0; -const OUT_171: usize = 1; -fn aiur_fn_171( - inp: [G; IN_171], +const INPUT_SIZE_173: usize = 0; +const IN_173: usize = 0; +const OUT_173: usize = 1; +fn aiur_fn_173( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], ExecError> { +) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(173); let __v_0: G = G::from_u64(128); let __v_1: G = G::from_u64(10); let __v_2: G = G::from_u64(138); @@ -18108,23 +18733,24 @@ fn aiur_fn_171( let __v_29: G = G::from_u64(3); let __v_30: G = G::from_u64(253); let __v_31: G = G::from_u64(31); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_171] = [__v_32]; - record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_173] = [__v_32]; + record.function_queries[173].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_172: usize = 0; -const IN_172: usize = 0; -const OUT_172: usize = 1; -fn aiur_fn_172( - inp: [G; IN_172], +const INPUT_SIZE_174: usize = 0; +const IN_174: usize = 0; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(174); let __v_0: G = G::from_u64(84); let __v_1: G = G::from_u64(115); let __v_2: G = G::from_u64(89); @@ -18157,23 +18783,24 @@ fn aiur_fn_172( let __v_29: G = G::from_u64(185); let __v_30: G = G::from_u64(12); let __v_31: G = G::from_u64(210); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_172] = [__v_32]; - record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_174] = [__v_32]; + record.function_queries[174].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 0; -const IN_173: usize = 0; -const OUT_173: usize = 1; -fn aiur_fn_173( - inp: [G; IN_173], +const INPUT_SIZE_175: usize = 0; +const IN_175: usize = 0; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_173], ExecError> { +) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(175); let __v_0: G = G::from_u64(27); let __v_1: G = G::from_u64(89); let __v_2: G = G::from_u64(17); @@ -18206,23 +18833,24 @@ fn aiur_fn_173( let __v_29: G = G::from_u64(248); let __v_30: G = G::from_u64(190); let __v_31: G = G::from_u64(213); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_173] = [__v_32]; - record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_175] = [__v_32]; + record.function_queries[175].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_174: usize = 0; -const IN_174: usize = 0; -const OUT_174: usize = 1; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_176: usize = 0; +const IN_176: usize = 0; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(176); let __v_0: G = G::from_u64(114); let __v_1: G = G::from_u64(198); let __v_2: G = G::from_u64(212); @@ -18255,23 +18883,24 @@ fn aiur_fn_174( let __v_29: G = G::from_u64(153); let __v_30: G = G::from_u64(98); let __v_31: G = G::from_u64(174); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_174] = [__v_32]; - record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_176] = [__v_32]; + record.function_queries[176].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_175: usize = 0; -const IN_175: usize = 0; -const OUT_175: usize = 1; -fn aiur_fn_175( - inp: [G; IN_175], +const INPUT_SIZE_177: usize = 0; +const IN_177: usize = 0; +const OUT_177: usize = 1; +fn aiur_fn_177( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(177); let __v_0: G = G::from_u64(195); let __v_1: G = G::from_u64(127); let __v_2: G = G::from_u64(46); @@ -18304,23 +18933,24 @@ fn aiur_fn_175( let __v_29: G = G::from_u64(212); let __v_30: G = G::from_u64(104); let __v_31: G = G::from_u64(142); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_175] = [__v_32]; - record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_177] = [__v_32]; + record.function_queries[177].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_176: usize = 0; -const IN_176: usize = 0; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_178: usize = 0; +const IN_178: usize = 0; +const OUT_178: usize = 1; +fn aiur_fn_178( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(178); let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); let __v_2: G = G::from_u64(99); @@ -18353,23 +18983,24 @@ fn aiur_fn_176( let __v_29: G = G::from_u64(240); let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(98); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_176] = [__v_32]; - record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_178] = [__v_32]; + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_177: usize = 0; -const IN_177: usize = 0; -const OUT_177: usize = 1; -fn aiur_fn_177( - inp: [G; IN_177], +const INPUT_SIZE_179: usize = 0; +const IN_179: usize = 0; +const OUT_179: usize = 1; +fn aiur_fn_179( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { +) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(179); let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); let __v_2: G = G::from_u64(43); @@ -18402,23 +19033,24 @@ fn aiur_fn_177( let __v_29: G = G::from_u64(244); let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_177] = [__v_32]; - record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_179] = [__v_32]; + record.function_queries[179].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_178: usize = 0; -const IN_178: usize = 0; -const OUT_178: usize = 1; -fn aiur_fn_178( - inp: [G; IN_178], +const INPUT_SIZE_180: usize = 0; +const IN_180: usize = 0; +const OUT_180: usize = 1; +fn aiur_fn_180( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(180); let __v_0: G = G::from_u64(80); let __v_1: G = G::from_u64(96); let __v_2: G = G::from_u64(162); @@ -18451,23 +19083,24 @@ fn aiur_fn_178( let __v_29: G = G::from_u64(49); let __v_30: G = G::from_u64(128); let __v_31: G = G::from_u64(13); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_178] = [__v_32]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_180] = [__v_32]; + record.function_queries[180].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_179: usize = 0; -const IN_179: usize = 0; -const OUT_179: usize = 1; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_181: usize = 0; +const IN_181: usize = 0; +const OUT_181: usize = 1; +fn aiur_fn_181( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_179], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(181); let __v_0: G = G::from_u64(132); let __v_1: G = G::from_u64(254); let __v_2: G = G::from_u64(61); @@ -18500,23 +19133,24 @@ fn aiur_fn_179( let __v_29: G = G::from_u64(7); let __v_30: G = G::from_u64(138); let __v_31: G = G::from_u64(37); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_179] = [__v_32]; - record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_181] = [__v_32]; + record.function_queries[181].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_180: usize = 0; -const IN_180: usize = 0; -const OUT_180: usize = 1; -fn aiur_fn_180( - inp: [G; IN_180], +const INPUT_SIZE_182: usize = 0; +const IN_182: usize = 0; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(182); let __v_0: G = G::from_u64(212); let __v_1: G = G::from_u64(215); let __v_2: G = G::from_u64(117); @@ -18549,23 +19183,24 @@ fn aiur_fn_180( let __v_29: G = G::from_u64(243); let __v_30: G = G::from_u64(38); let __v_31: G = G::from_u64(12); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_180] = [__v_32]; - record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_182] = [__v_32]; + record.function_queries[182].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_181: usize = 0; -const IN_181: usize = 0; -const OUT_181: usize = 1; -fn aiur_fn_181( - inp: [G; IN_181], +const INPUT_SIZE_183: usize = 0; +const IN_183: usize = 0; +const OUT_183: usize = 1; +fn aiur_fn_183( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(183); let __v_0: G = G::from_u64(32); let __v_1: G = G::from_u64(117); let __v_2: G = G::from_u64(189); @@ -18598,23 +19233,24 @@ fn aiur_fn_181( let __v_29: G = G::from_u64(62); let __v_30: G = G::from_u64(185); let __v_31: G = G::from_u64(93); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_32]; - record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_183] = [__v_32]; + record.function_queries[183].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_182: usize = 0; -const IN_182: usize = 0; -const OUT_182: usize = 1; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_184: usize = 0; +const IN_184: usize = 0; +const OUT_184: usize = 1; +fn aiur_fn_184( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(184); let __v_0: G = G::from_u64(126); let __v_1: G = G::from_u64(78); let __v_2: G = G::from_u64(155); @@ -18647,23 +19283,24 @@ fn aiur_fn_182( let __v_29: G = G::from_u64(229); let __v_30: G = G::from_u64(145); let __v_31: G = G::from_u64(88); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_182] = [__v_32]; - record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_184] = [__v_32]; + record.function_queries[184].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_183: usize = 0; -const IN_183: usize = 0; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_185: usize = 0; +const IN_185: usize = 0; +const OUT_185: usize = 1; +fn aiur_fn_185( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(185); let __v_0: G = G::from_u64(128); let __v_1: G = G::from_u64(249); let __v_2: G = G::from_u64(117); @@ -18696,87 +19333,88 @@ fn aiur_fn_183( let __v_29: G = G::from_u64(102); let __v_30: G = G::from_u64(78); let __v_31: G = G::from_u64(108); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_183] = [__v_32]; - record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_185] = [__v_32]; + record.function_queries[185].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_184: usize = 1; -const IN_184: usize = 1; -const OUT_184: usize = 1; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_186: usize = 1; +const IN_186: usize = 1; +const OUT_186: usize = 1; +fn aiur_fn_186( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + record.checkpoint(186); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[180].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i)?; } record.function_queries[180].output_at(__i).to_array::() }, _ => aiur_fn_180(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_184] = [__v_3]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_186] = [__v_3]; + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[181].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i)?; } record.function_queries[181].output_at(__i).to_array::() }, _ => aiur_fn_181(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_184] = [__v_5]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_186] = [__v_5]; + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[182].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i)?; } record.function_queries[182].output_at(__i).to_array::() }, _ => aiur_fn_182(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_184] = [__v_7]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_186] = [__v_7]; + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_184] = [__v_9]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_186] = [__v_9]; + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[184].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i)?; } record.function_queries[184].output_at(__i).to_array::() }, _ => aiur_fn_184(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_184] = [__v_11]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_186] = [__v_11]; + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_184] = [__v_11]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_186] = [__v_11]; + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -18791,16 +19429,17 @@ fn aiur_fn_184( }) } -const INPUT_SIZE_185: usize = 0; -const IN_185: usize = 0; -const OUT_185: usize = 1; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_187: usize = 0; +const IN_187: usize = 0; +const OUT_187: usize = 1; +fn aiur_fn_187( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(187); let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(64); let __v_2: G = G::from_u64(0); @@ -18812,28 +19451,29 @@ fn aiur_fn_185( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_185] = [__v_16]; - record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_187] = [__v_16]; + record.function_queries[187].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_186: usize = 0; -const IN_186: usize = 0; -const OUT_186: usize = 1; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_188: usize = 0; +const IN_188: usize = 0; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(188); let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(0); @@ -18845,80 +19485,81 @@ fn aiur_fn_186( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_16]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_188] = [__v_16]; + record.function_queries[188].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_187: usize = 3; -const IN_187: usize = 3; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_189: usize = 3; +const IN_189: usize = 3; +const OUT_189: usize = 2; +fn aiur_fn_189( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], 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]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + record.checkpoint(189); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[180].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i)?; } record.function_queries[180].output_at(__i).to_array::() }, _ => aiur_fn_180(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_187] = [__v_5, __v_6]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_189] = [__v_5, __v_6]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[181].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i)?; } record.function_queries[181].output_at(__i).to_array::() }, _ => aiur_fn_181(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_187] = [__v_7, __v_8]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_189] = [__v_7, __v_8]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[184].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i)?; } record.function_queries[184].output_at(__i).to_array::() }, _ => aiur_fn_184(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_187] = [__v_9, __v_10]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_189] = [__v_9, __v_10]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[182].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i)?; } record.function_queries[182].output_at(__i).to_array::() }, _ => aiur_fn_182(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -18927,48 +19568,48 @@ fn aiur_fn_187( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_14, __v_18]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_189] = [__v_14, __v_18]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_16.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_17, __v_21]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_189] = [__v_17, __v_21]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_18, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_18, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[191].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[191].bump_multiplicity(__i)?; } record.function_queries[191].output_at(__i).to_array::() }, _ => aiur_fn_191(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_187] = [__v_20, __v_21]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_189] = [__v_20, __v_21]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[192].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[192].bump_multiplicity(__i)?; } record.function_queries[192].output_at(__i).to_array::() }, _ => aiur_fn_192(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_187] = [__v_20, __v_21]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_189] = [__v_20, __v_21]; + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -18985,57 +19626,58 @@ fn aiur_fn_187( }) } -const INPUT_SIZE_188: usize = 1; -const IN_188: usize = 1; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_190: usize = 1; +const IN_190: usize = 1; +const OUT_190: usize = 2; +fn aiur_fn_190( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_188], 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_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(190); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_4, __v_8]; - record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_190] = [__v_4, __v_8]; + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[185].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i)?; } record.function_queries[185].output_at(__i).to_array::() }, _ => aiur_fn_185(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_188] = [__v_14, __v_15]; - record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_190] = [__v_14, __v_15]; + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19043,9 +19685,9 @@ fn aiur_fn_188( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_14, __v_18]; - record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_190] = [__v_14, __v_18]; + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19055,9 +19697,9 @@ fn aiur_fn_188( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_188] = [__v_12, __v_16]; - record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_190] = [__v_12, __v_16]; + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19066,31 +19708,32 @@ fn aiur_fn_188( }) } -const INPUT_SIZE_189: usize = 1; -const IN_189: usize = 1; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_191: usize = 1; +const IN_191: usize = 1; +const OUT_191: usize = 2; +fn aiur_fn_191( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(191); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[179].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i)?; } record.function_queries[179].output_at(__i).to_array::() }, _ => aiur_fn_179(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { @@ -19099,15 +19742,15 @@ fn aiur_fn_189( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_10, __v_14]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_191] = [__v_10, __v_14]; + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_189] = [__v_10, __v_0]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_191] = [__v_10, __v_0]; + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19117,27 +19760,28 @@ fn aiur_fn_189( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_5, __v_9]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_191] = [__v_5, __v_9]; + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_190: usize = 1; -const IN_190: usize = 1; -const OUT_190: usize = 2; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_192: usize = 1; +const IN_192: usize = 1; +const OUT_192: usize = 2; +fn aiur_fn_192( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(192); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19147,8 +19791,8 @@ fn aiur_fn_190( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_190] = [__v_5, __v_0]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_192] = [__v_5, __v_0]; + record.function_queries[192].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19156,9 +19800,9 @@ fn aiur_fn_190( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_5, __v_9]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_192] = [__v_5, __v_9]; + record.function_queries[192].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19168,25 +19812,26 @@ fn aiur_fn_190( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_190] = [__v_5, __v_9]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_192] = [__v_5, __v_9]; + record.function_queries[192].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_191: usize = 0; -const IN_191: usize = 0; -const OUT_191: usize = 1; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_193: usize = 0; +const IN_193: usize = 0; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(193); let __v_0: G = G::from_u64(172); let __v_1: G = G::from_u64(217); let __v_2: G = G::from_u64(240); @@ -19219,23 +19864,24 @@ fn aiur_fn_191( let __v_29: G = G::from_u64(68); let __v_30: G = G::from_u64(103); let __v_31: G = G::from_u64(141); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_191] = [__v_32]; - record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_193] = [__v_32]; + record.function_queries[193].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_192: usize = 0; -const IN_192: usize = 0; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_194: usize = 0; +const IN_194: usize = 0; +const OUT_194: usize = 1; +fn aiur_fn_194( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(194); let __v_0: G = G::from_u64(87); let __v_1: G = G::from_u64(33); let __v_2: G = G::from_u64(202); @@ -19268,23 +19914,24 @@ fn aiur_fn_192( let __v_29: G = G::from_u64(220); let __v_30: G = G::from_u64(219); let __v_31: G = G::from_u64(138); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_32]; - record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_194] = [__v_32]; + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_193: usize = 0; -const IN_193: usize = 0; -const OUT_193: usize = 1; -fn aiur_fn_193( - inp: [G; IN_193], +const INPUT_SIZE_195: usize = 0; +const IN_195: usize = 0; +const OUT_195: usize = 1; +fn aiur_fn_195( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_193], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(195); let __v_0: G = G::from_u64(199); let __v_1: G = G::from_u64(25); let __v_2: G = G::from_u64(42); @@ -19317,23 +19964,24 @@ fn aiur_fn_193( let __v_29: G = G::from_u64(131); let __v_30: G = G::from_u64(176); let __v_31: G = G::from_u64(74); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_193] = [__v_32]; - record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_195] = [__v_32]; + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_194: usize = 0; -const IN_194: usize = 0; -const OUT_194: usize = 1; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_196: usize = 0; +const IN_196: usize = 0; +const OUT_196: usize = 1; +fn aiur_fn_196( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(196); let __v_0: G = G::from_u64(141); let __v_1: G = G::from_u64(87); let __v_2: G = G::from_u64(199); @@ -19366,23 +20014,24 @@ fn aiur_fn_194( let __v_29: G = G::from_u64(206); let __v_30: G = G::from_u64(30); let __v_31: G = G::from_u64(182); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_194] = [__v_32]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_196] = [__v_32]; + record.function_queries[196].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_195: usize = 0; -const IN_195: usize = 0; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_197: usize = 0; +const IN_197: usize = 0; +const OUT_197: usize = 1; +fn aiur_fn_197( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(197); let __v_0: G = G::from_u64(209); let __v_1: G = G::from_u64(16); let __v_2: G = G::from_u64(124); @@ -19415,23 +20064,24 @@ fn aiur_fn_195( let __v_29: G = G::from_u64(74); let __v_30: G = G::from_u64(126); let __v_31: G = G::from_u64(68); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_32]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_197] = [__v_32]; + record.function_queries[197].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_196: usize = 0; -const IN_196: usize = 0; -const OUT_196: usize = 1; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_198: usize = 0; +const IN_198: usize = 0; +const OUT_198: usize = 1; +fn aiur_fn_198( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(198); let __v_0: G = G::from_u64(198); let __v_1: G = G::from_u64(157); let __v_2: G = G::from_u64(244); @@ -19464,63 +20114,64 @@ fn aiur_fn_196( let __v_29: G = G::from_u64(161); let __v_30: G = G::from_u64(111); let __v_31: G = G::from_u64(4); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_32]; - record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_198] = [__v_32]; + record.function_queries[198].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_197: usize = 1; -const IN_197: usize = 1; -const OUT_197: usize = 1; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_199: usize = 1; +const IN_199: usize = 1; +const OUT_199: usize = 1; +fn aiur_fn_199( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } }; + record.checkpoint(199); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[193].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i)?; } record.function_queries[193].output_at(__i).to_array::() }, _ => aiur_fn_193(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_197] = [__v_3]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_199] = [__v_3]; + record.function_queries[199].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_197] = [__v_5]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_199] = [__v_5]; + record.function_queries[199].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[197].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i)?; } record.function_queries[197].output_at(__i).to_array::() }, _ => aiur_fn_197(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_197] = [__v_7]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_199] = [__v_7]; + record.function_queries[199].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_197] = [__v_7]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_199] = [__v_7]; + record.function_queries[199].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19531,61 +20182,63 @@ fn aiur_fn_197( }) } -const INPUT_SIZE_198: usize = 1; -const IN_198: usize = 1; -const OUT_198: usize = 1; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_200: usize = 1; +const IN_200: usize = 1; +const OUT_200: usize = 1; +fn aiur_fn_200( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(200); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[179].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i)?; } record.function_queries[179].output_at(__i).to_array::() }, _ => aiur_fn_179(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7]; - record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_200] = [__v_7]; + record.function_queries[200].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_7]; - record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_200] = [__v_7]; + record.function_queries[200].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_199: usize = 2; -const IN_199: usize = 2; -const OUT_199: usize = 2; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_201: usize = 2; +const IN_201: usize = 2; +const OUT_201: usize = 2; +fn aiur_fn_201( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + record.checkpoint(201); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, 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]; @@ -19594,13 +20247,13 @@ fn aiur_fn_199( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_5, __v_8]; - record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_201] = [__v_5, __v_8]; + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -19608,13 +20261,13 @@ fn aiur_fn_199( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_7, __v_10]; - record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_201] = [__v_7, __v_10]; + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -19622,9 +20275,9 @@ fn aiur_fn_199( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_9, __v_12]; - record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_201] = [__v_9, __v_12]; + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -19639,17 +20292,17 @@ fn aiur_fn_199( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_21, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_21: G = { let __values: [G; 10] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_21, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_6, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_6, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_199] = [__v_23, __v_25]; - record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_201] = [__v_23, __v_25]; + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19669,43 +20322,44 @@ fn aiur_fn_199( }) } -const INPUT_SIZE_200: usize = 1; -const IN_200: usize = 1; -const OUT_200: usize = 2; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_202: usize = 1; +const IN_202: usize = 1; +const OUT_202: usize = 2; +fn aiur_fn_202( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(202); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_4, __v_8]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_202] = [__v_4, __v_8]; + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -19714,13 +20368,13 @@ fn aiur_fn_200( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_12, __v_16]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_202] = [__v_12, __v_16]; + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -19729,21 +20383,21 @@ fn aiur_fn_200( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_14, __v_18]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_202] = [__v_14, __v_18]; + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_200] = [__v_17, __v_18]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_202] = [__v_17, __v_18]; + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19760,49 +20414,50 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 1; -const IN_201: usize = 1; -const OUT_201: usize = 2; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_203: usize = 1; +const IN_203: usize = 1; +const OUT_203: usize = 2; +fn aiur_fn_203( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(203); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_4, __v_8]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_4, __v_8]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { @@ -19810,44 +20465,44 @@ fn aiur_fn_201( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_14, __v_18]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_14, __v_18]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); - let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_16.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_17, __v_21]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_17, __v_21]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[195].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[195].bump_multiplicity(__i)?; } record.function_queries[195].output_at(__i).to_array::() }, _ => aiur_fn_195(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 0u64 => { @@ -19855,51 +20510,51 @@ fn aiur_fn_201( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_27, __v_31]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_31: G = { let __values: [G; 4] = [__v_28, __v_29, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_27, __v_31]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); - let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_29.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_30, __v_34]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_30, __v_34]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_20, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_20, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); let __v_40: G = G::from_u64(1); - let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_201] = [__v_45, __v_46]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_203] = [__v_45, __v_46]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19911,9 +20566,9 @@ fn aiur_fn_201( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_25, __v_29]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_25, __v_29]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19927,9 +20582,9 @@ fn aiur_fn_201( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_12, __v_16]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_203] = [__v_12, __v_16]; + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19938,34 +20593,35 @@ fn aiur_fn_201( }) } -const INPUT_SIZE_202: usize = 1; -const IN_202: usize = 1; -const OUT_202: usize = 3; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_204: usize = 1; +const IN_204: usize = 1; +const OUT_204: usize = 3; +fn aiur_fn_204( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(204); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[194].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i)?; } record.function_queries[194].output_at(__i).to_array::() }, _ => aiur_fn_194(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -19973,13 +20629,13 @@ fn aiur_fn_202( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_202] = [__v_12, __v_14, __v_16]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_204] = [__v_12, __v_14, __v_16]; + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19987,13 +20643,13 @@ fn aiur_fn_202( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_12, __v_16, __v_20]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_204] = [__v_12, __v_16, __v_20]; + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20003,13 +20659,13 @@ fn aiur_fn_202( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_9, __v_13, __v_17]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_204] = [__v_9, __v_13, __v_17]; + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20019,63 +20675,64 @@ fn aiur_fn_202( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_7, __v_11, __v_15]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_204] = [__v_7, __v_11, __v_15]; + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_203: usize = 3; -const IN_203: usize = 3; -const OUT_203: usize = 2; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_205: usize = 3; +const IN_205: usize = 3; +const OUT_205: usize = 2; +fn aiur_fn_205( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_203], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } }; + record.checkpoint(205); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[193].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i)?; } record.function_queries[193].output_at(__i).to_array::() }, _ => aiur_fn_193(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); - let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_7.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_8, __v_12]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_205] = [__v_8, __v_12]; + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[389].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { *(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389]) }; __ret }, _ => aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[395].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i)?; } record.function_queries[395].output_at(__i).to_array::() }, _ => aiur_fn_395(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -20084,17 +20741,17 @@ fn aiur_fn_203( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_15, __v_19]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_205] = [__v_15, __v_19]; + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_203] = [__v_15, __v_16]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_205] = [__v_15, __v_16]; + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20105,33 +20762,33 @@ fn aiur_fn_203( } }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_203] = [__v_8, __v_9]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_205] = [__v_8, __v_9]; + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[197].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i)?; } record.function_queries[197].output_at(__i).to_array::() }, _ => aiur_fn_197(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[203].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[203].bump_multiplicity(__i)?; } record.function_queries[203].output_at(__i).to_array::() }, _ => aiur_fn_203(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_203] = [__v_9, __v_10]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_205] = [__v_9, __v_10]; + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20139,9 +20796,9 @@ fn aiur_fn_203( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_9, __v_13]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_205] = [__v_9, __v_13]; + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20152,65 +20809,66 @@ fn aiur_fn_203( }) } -const INPUT_SIZE_204: usize = 2; -const IN_204: usize = 2; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_206: usize = 2; +const IN_206: usize = 2; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + record.checkpoint(206); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_204] = [__v_2]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_206] = [__v_2]; + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_204] = [__v_2]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_206] = [__v_2]; + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !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_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_204] = [__v_2]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_206] = [__v_2]; + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_10, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_204] = [__v_19]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_206] = [__v_19]; + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20230,41 +20888,43 @@ 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_207: usize = 2; +const IN_207: usize = 2; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(207); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_205] = [__v_5]; - record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_207] = [__v_5]; + record.function_queries[207].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_206: usize = 0; -const IN_206: usize = 0; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_208: usize = 0; +const IN_208: usize = 0; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(208); let __v_0: G = G::from_u64(177); let __v_1: G = G::from_u64(246); let __v_2: G = G::from_u64(240); @@ -20297,23 +20957,24 @@ fn aiur_fn_206( let __v_29: G = G::from_u64(199); let __v_30: G = G::from_u64(17); let __v_31: G = G::from_u64(5); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_206] = [__v_32]; - record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_208] = [__v_32]; + record.function_queries[208].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_207: usize = 0; -const IN_207: usize = 0; -const OUT_207: usize = 1; -fn aiur_fn_207( - inp: [G; IN_207], +const INPUT_SIZE_209: usize = 0; +const IN_209: usize = 0; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_207], ExecError> { +) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(209); let __v_0: G = G::from_u64(182); let __v_1: G = G::from_u64(236); let __v_2: G = G::from_u64(45); @@ -20346,23 +21007,24 @@ fn aiur_fn_207( let __v_29: G = G::from_u64(223); let __v_30: G = G::from_u64(113); let __v_31: G = G::from_u64(248); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_207] = [__v_32]; - record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_209] = [__v_32]; + record.function_queries[209].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_208: usize = 0; -const IN_208: usize = 0; -const OUT_208: usize = 1; -fn aiur_fn_208( - inp: [G; IN_208], +const INPUT_SIZE_210: usize = 0; +const IN_210: usize = 0; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_208], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(210); let __v_0: G = G::from_u64(213); let __v_1: G = G::from_u64(77); let __v_2: G = G::from_u64(183); @@ -20395,23 +21057,24 @@ fn aiur_fn_208( let __v_29: G = G::from_u64(221); let __v_30: G = G::from_u64(68); let __v_31: G = G::from_u64(184); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_32]; - record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_210] = [__v_32]; + record.function_queries[210].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_209: usize = 0; -const IN_209: usize = 0; -const OUT_209: usize = 1; -fn aiur_fn_209( - inp: [G; IN_209], +const INPUT_SIZE_211: usize = 0; +const IN_211: usize = 0; +const OUT_211: usize = 1; +fn aiur_fn_211( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_209], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(211); let __v_0: G = G::from_u64(41); let __v_1: G = G::from_u64(86); let __v_2: G = G::from_u64(61); @@ -20444,23 +21107,24 @@ fn aiur_fn_209( let __v_29: G = G::from_u64(179); let __v_30: G = G::from_u64(107); let __v_31: G = G::from_u64(42); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_209] = [__v_32]; - record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_211] = [__v_32]; + record.function_queries[211].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_210: usize = 0; -const IN_210: usize = 0; -const OUT_210: usize = 1; -fn aiur_fn_210( - inp: [G; IN_210], +const INPUT_SIZE_212: usize = 0; +const IN_212: usize = 0; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_210], ExecError> { +) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(212); let __v_0: G = G::from_u64(60); let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(73); @@ -20493,23 +21157,24 @@ fn aiur_fn_210( let __v_29: G = G::from_u64(183); let __v_30: G = G::from_u64(44); let __v_31: G = G::from_u64(66); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_210] = [__v_32]; - record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_212] = [__v_32]; + record.function_queries[212].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_211: usize = 0; -const IN_211: usize = 0; -const OUT_211: usize = 1; -fn aiur_fn_211( - inp: [G; IN_211], +const INPUT_SIZE_213: usize = 0; +const IN_213: usize = 0; +const OUT_213: usize = 1; +fn aiur_fn_213( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_211], ExecError> { +) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(213); let __v_0: G = G::from_u64(209); let __v_1: G = G::from_u64(224); let __v_2: G = G::from_u64(128); @@ -20542,23 +21207,24 @@ fn aiur_fn_211( let __v_29: G = G::from_u64(209); let __v_30: G = G::from_u64(136); let __v_31: G = G::from_u64(196); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_211] = [__v_32]; - record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_213] = [__v_32]; + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_212: usize = 0; -const IN_212: usize = 0; -const OUT_212: usize = 1; -fn aiur_fn_212( - inp: [G; IN_212], +const INPUT_SIZE_214: usize = 0; +const IN_214: usize = 0; +const OUT_214: usize = 1; +fn aiur_fn_214( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_212], ExecError> { +) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(214); let __v_0: G = G::from_u64(213); let __v_1: G = G::from_u64(84); let __v_2: G = G::from_u64(41); @@ -20591,23 +21257,24 @@ fn aiur_fn_212( let __v_29: G = G::from_u64(197); let __v_30: G = G::from_u64(199); let __v_31: G = G::from_u64(137); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_212] = [__v_32]; - record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_214] = [__v_32]; + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_213: usize = 0; -const IN_213: usize = 0; -const OUT_213: usize = 1; -fn aiur_fn_213( - inp: [G; IN_213], +const INPUT_SIZE_215: usize = 0; +const IN_215: usize = 0; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_213], ExecError> { +) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(215); let __v_0: G = G::from_u64(63); let __v_1: G = G::from_u64(146); let __v_2: G = G::from_u64(164); @@ -20640,23 +21307,24 @@ fn aiur_fn_213( let __v_29: G = G::from_u64(217); let __v_30: G = G::from_u64(11); let __v_31: G = G::from_u64(107); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_213] = [__v_32]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_215] = [__v_32]; + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_214: usize = 0; -const IN_214: usize = 0; -const OUT_214: usize = 1; -fn aiur_fn_214( - inp: [G; IN_214], +const INPUT_SIZE_216: usize = 0; +const IN_216: usize = 0; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_214], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(216); let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(163); let __v_2: G = G::from_u64(16); @@ -20689,23 +21357,24 @@ fn aiur_fn_214( let __v_29: G = G::from_u64(227); let __v_30: G = G::from_u64(223); let __v_31: G = G::from_u64(102); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_214] = [__v_32]; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_216] = [__v_32]; + record.function_queries[216].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_215: usize = 0; -const IN_215: usize = 0; -const OUT_215: usize = 1; -fn aiur_fn_215( - inp: [G; IN_215], +const INPUT_SIZE_217: usize = 0; +const IN_217: usize = 0; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_215], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(217); let __v_0: G = G::from_u64(173); let __v_1: G = G::from_u64(112); let __v_2: G = G::from_u64(12); @@ -20738,23 +21407,24 @@ fn aiur_fn_215( let __v_29: G = G::from_u64(105); let __v_30: G = G::from_u64(235); let __v_31: G = G::from_u64(156); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_215] = [__v_32]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_217] = [__v_32]; + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_216: usize = 0; -const IN_216: usize = 0; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +const INPUT_SIZE_218: usize = 0; +const IN_218: usize = 0; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_216], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(218); let __v_0: G = G::from_u64(216); let __v_1: G = G::from_u64(56); let __v_2: G = G::from_u64(187); @@ -20787,23 +21457,24 @@ fn aiur_fn_216( let __v_29: G = G::from_u64(112); let __v_30: G = G::from_u64(83); let __v_31: G = G::from_u64(8); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_32]; - record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_218] = [__v_32]; + record.function_queries[218].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_217: usize = 0; -const IN_217: usize = 0; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], +const INPUT_SIZE_219: usize = 0; +const IN_219: usize = 0; +const OUT_219: usize = 1; +fn aiur_fn_219( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(219); let __v_0: G = G::from_u64(214); let __v_1: G = G::from_u64(22); let __v_2: G = G::from_u64(50); @@ -20836,23 +21507,24 @@ fn aiur_fn_217( let __v_29: G = G::from_u64(129); let __v_30: G = G::from_u64(251); let __v_31: G = G::from_u64(119); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_32]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_219] = [__v_32]; + record.function_queries[219].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_218: usize = 0; -const IN_218: usize = 0; -const OUT_218: usize = 1; -fn aiur_fn_218( - inp: [G; IN_218], +const INPUT_SIZE_220: usize = 0; +const IN_220: usize = 0; +const OUT_220: usize = 1; +fn aiur_fn_220( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(220); let __v_0: G = G::from_u64(66); let __v_1: G = G::from_u64(136); let __v_2: G = G::from_u64(249); @@ -20885,111 +21557,112 @@ fn aiur_fn_218( let __v_29: G = G::from_u64(253); let __v_30: G = G::from_u64(159); let __v_31: G = G::from_u64(173); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_218] = [__v_32]; - record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_220] = [__v_32]; + record.function_queries[220].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_219: usize = 1; -const IN_219: usize = 1; -const OUT_219: usize = 1; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_221: usize = 1; +const IN_221: usize = 1; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + record.checkpoint(221); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_3]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_3]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_5]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_5]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_7]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_7]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_9]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_9]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[216].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i)?; } record.function_queries[216].output_at(__i).to_array::() }, _ => aiur_fn_216(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_11]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_11]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[217].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i)?; } record.function_queries[217].output_at(__i).to_array::() }, _ => aiur_fn_217(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_13]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_13]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[219].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i)?; } record.function_queries[219].output_at(__i).to_array::() }, _ => aiur_fn_219(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_219] = [__v_15]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_15]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_219] = [__v_15]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_221] = [__v_15]; + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21008,33 +21681,34 @@ fn aiur_fn_219( }) } -const INPUT_SIZE_220: usize = 3; -const IN_220: usize = 3; -const OUT_220: usize = 2; -fn aiur_fn_220( - inp: [G; IN_220], +const INPUT_SIZE_222: usize = 3; +const IN_222: usize = 3; +const OUT_222: usize = 2; +fn aiur_fn_222( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_220], 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]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(222); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_7, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[236].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i)?; } record.function_queries[236].output_at(__i).to_array::() }, _ => aiur_fn_236(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -21043,9 +21717,9 @@ fn aiur_fn_220( let __v_11: G = G::from_u64(7); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -21053,9 +21727,9 @@ fn aiur_fn_220( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21068,38 +21742,38 @@ fn aiur_fn_220( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_6, __v_10]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_6, __v_10]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_10, __v_14]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -21108,17 +21782,17 @@ fn aiur_fn_220( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(7); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_18, __v_22]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_17, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_18, __v_22]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21126,9 +21800,9 @@ fn aiur_fn_220( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_16, __v_20]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_16, __v_20]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21138,9 +21812,9 @@ fn aiur_fn_220( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_16, __v_20]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_16, __v_20]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21148,89 +21822,89 @@ fn aiur_fn_220( } }, _ => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_10, __v_11]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_222] = [__v_10, __v_11]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[216].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i)?; } record.function_queries[216].output_at(__i).to_array::() }, _ => aiur_fn_216(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_12, __v_13]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_222] = [__v_12, __v_13]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[217].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i)?; } record.function_queries[217].output_at(__i).to_array::() }, _ => aiur_fn_217(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[224].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i)?; } record.function_queries[224].output_at(__i).to_array::() }, _ => aiur_fn_224(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_14, __v_15]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_222] = [__v_14, __v_15]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[219].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i)?; } record.function_queries[219].output_at(__i).to_array::() }, _ => aiur_fn_219(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[530].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i)?; } record.function_queries[530].output_at(__i).to_array::() }, _ => aiur_fn_530(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_16, __v_17]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_222] = [__v_16, __v_17]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; match __v_17.as_canonical_u64() { 1u64 => { let __v_18: G = G::from_u64(2); - let __v_19: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_19: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_19.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_20, __v_24]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_20, __v_24]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; @@ -21239,7 +21913,7 @@ fn aiur_fn_220( 7u64 => { match __v_25.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; @@ -21248,15 +21922,15 @@ fn aiur_fn_220( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_26, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_26, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_33, __v_37]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_33, __v_37]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21264,9 +21938,9 @@ fn aiur_fn_220( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_32, __v_36]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_32, __v_36]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21276,9 +21950,9 @@ fn aiur_fn_220( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); - let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_32, __v_36]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_36: G = { let __values: [G; 4] = [__v_33, __v_34, __v_35, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_32, __v_36]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21288,9 +21962,9 @@ fn aiur_fn_220( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_28, __v_32]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_28, __v_32]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21300,9 +21974,9 @@ fn aiur_fn_220( let __v_29: G = G::from_u64(0); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_28, __v_32]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_28, __v_32]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21314,9 +21988,9 @@ fn aiur_fn_220( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_220] = [__v_18, __v_22]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_222] = [__v_18, __v_22]; + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21335,37 +22009,38 @@ fn aiur_fn_220( }) } -const INPUT_SIZE_221: usize = 1; -const IN_221: usize = 1; -const OUT_221: usize = 2; -fn aiur_fn_221( - inp: [G; IN_221], +const INPUT_SIZE_223: usize = 1; +const IN_223: usize = 1; +const OUT_223: usize = 2; +fn aiur_fn_223( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_221], ExecError> { +) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(223); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_4, __v_8]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_223] = [__v_4, __v_8]; + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -21374,28 +22049,28 @@ fn aiur_fn_221( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 4] = [__v_16, __v_17, __v_20, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_23, __v_26]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_223] = [__v_23, __v_26]; + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21403,9 +22078,9 @@ fn aiur_fn_221( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_10, __v_14]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_223] = [__v_10, __v_14]; + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21415,9 +22090,9 @@ fn aiur_fn_221( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_221] = [__v_10, __v_14]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_223] = [__v_10, __v_14]; + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21426,37 +22101,38 @@ fn aiur_fn_221( }) } -const INPUT_SIZE_222: usize = 1; -const IN_222: usize = 1; -const OUT_222: usize = 2; -fn aiur_fn_222( - inp: [G; IN_222], +const INPUT_SIZE_224: usize = 1; +const IN_224: usize = 1; +const OUT_224: usize = 2; +fn aiur_fn_224( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_222], ExecError> { +) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(224); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_4, __v_8]; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_224] = [__v_4, __v_8]; + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -21465,7 +22141,7 @@ fn aiur_fn_222( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -21473,15 +22149,15 @@ fn aiur_fn_222( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[218].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i)?; } record.function_queries[218].output_at(__i).to_array::() }, _ => aiur_fn_218(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_13, __v_20]; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_224] = [__v_13, __v_20]; + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21489,9 +22165,9 @@ fn aiur_fn_222( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_13, __v_17]; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_224] = [__v_13, __v_17]; + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21501,9 +22177,9 @@ fn aiur_fn_222( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_10, __v_14]; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_224] = [__v_10, __v_14]; + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21513,9 +22189,9 @@ fn aiur_fn_222( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_10, __v_14]; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_224] = [__v_10, __v_14]; + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21524,34 +22200,35 @@ fn aiur_fn_222( }) } -const INPUT_SIZE_223: usize = 1; -const IN_223: usize = 1; -const OUT_223: usize = 0; -fn aiur_fn_223( - inp: [G; IN_223], +const INPUT_SIZE_225: usize = 1; +const IN_225: usize = 1; +const OUT_225: usize = 0; +fn aiur_fn_225( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_223], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(225); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_225] = []; + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[225].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i)?; } record.function_queries[225].output_at(__i).to_array::() }, _ => aiur_fn_225(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_225] = []; + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21561,56 +22238,58 @@ fn aiur_fn_223( }) } -const INPUT_SIZE_224: usize = 1; -const IN_224: usize = 1; -const OUT_224: usize = 1; -fn aiur_fn_224( - inp: [G; IN_224], +const INPUT_SIZE_226: usize = 1; +const IN_226: usize = 1; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_224], ExecError> { +) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(226); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[227].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i)?; } record.function_queries[227].output_at(__i).to_array::() }, _ => aiur_fn_227(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_224] = [__v_2]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_226] = [__v_2]; + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_225: usize = 2; -const IN_225: usize = 2; -const OUT_225: usize = 1; -fn aiur_fn_225( - inp: [G; IN_225], +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 1; +fn aiur_fn_227( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_225], ExecError> { +) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(227); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_225] = [__v_1]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_227] = [__v_1]; + record.function_queries[227].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[227].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i)?; } record.function_queries[227].output_at(__i).to_array::() }, _ => aiur_fn_227(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_225] = [__v_7]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_227] = [__v_7]; + record.function_queries[227].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21620,29 +22299,30 @@ fn aiur_fn_225( }) } -const INPUT_SIZE_226: usize = 1; -const IN_226: usize = 1; -const OUT_226: usize = 1; -fn aiur_fn_226( - inp: [G; IN_226], +const INPUT_SIZE_228: usize = 1; +const IN_228: usize = 1; +const OUT_228: usize = 1; +fn aiur_fn_228( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_226], ExecError> { +) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(228); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(128); - let __v_2: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record) }; + let __v_2: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_1)?; Bytes2::less_than(&__v_0, &__v_1) } else { bytes2_less_than_value(__v_0, __v_1, record)? }; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(192); - let __v_4: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_3) } else { bytes2_less_than_value(__v_0, __v_3, record) }; + let __v_4: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_3)?; Bytes2::less_than(&__v_0, &__v_3) } else { bytes2_less_than_value(__v_0, __v_3, record)? }; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); - let __ret: [G; OUT_226] = [__v_6]; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_228] = [__v_6]; + record.function_queries[228].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21657,36 +22337,37 @@ fn aiur_fn_226( }) } -const INPUT_SIZE_227: usize = 2; -const IN_227: usize = 2; -const OUT_227: usize = 2; -fn aiur_fn_227( - inp: [G; IN_227], +const INPUT_SIZE_229: usize = 2; +const IN_229: usize = 2; +const OUT_229: usize = 2; +fn aiur_fn_229( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_227], ExecError> { +) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(229); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(128); - let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; + let __v_3: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_2)?; Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record)? }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_227] = [__v_0, __v_1]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_229] = [__v_0, __v_1]; + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(194); - let __v_5: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_4) } else { bytes2_less_than_value(__v_0, __v_4, record) }; + let __v_5: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::less_than(&__v_0, &__v_4) } else { bytes2_less_than_value(__v_0, __v_4, record)? }; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(224); - let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) }; + let __v_7: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_6)?; Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record)? }; match __v_7.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -21696,11 +22377,11 @@ fn aiur_fn_227( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); - let __ret: [G; OUT_227] = [__v_16, __v_10]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_229] = [__v_16, __v_10]; + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21710,16 +22391,16 @@ fn aiur_fn_227( }, _ => { let __v_8: G = G::from_u64(240); - let __v_9: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_8) } else { bytes2_less_than_value(__v_0, __v_8, record) }; + let __v_9: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_8)?; Bytes2::less_than(&__v_0, &__v_8) } else { bytes2_less_than_value(__v_0, __v_8, record)? }; match __v_9.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -21729,20 +22410,20 @@ fn aiur_fn_227( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); let __v_26: G = G::from_u64(2048); - let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_27.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_227] = [__v_25, __v_15]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_229] = [__v_25, __v_15]; + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21761,19 +22442,19 @@ fn aiur_fn_227( } }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; @@ -21783,25 +22464,25 @@ fn aiur_fn_227( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); let __v_32: G = (__v_22 + __v_31); let __v_33: G = G::from_u64(65536); - let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_34.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_227] = [__v_32, __v_18]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_229] = [__v_32, __v_18]; + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21837,123 +22518,125 @@ fn aiur_fn_227( }) } -const INPUT_SIZE_228: usize = 1; -const IN_228: usize = 1; -const OUT_228: usize = 1; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_230: usize = 1; +const IN_230: usize = 1; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_228], ExecError> { +) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(230); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[212].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[212].bump_multiplicity(__i)?; } record.function_queries[212].output_at(__i).to_array::() }, _ => aiur_fn_212(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; let __hit = record.function_queries[212].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[214].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i)?; } record.function_queries[214].output_at(__i).to_array::() }, _ => aiur_fn_214(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 4] = [__v_31, __v_32, __v_35, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_38: G = G::from_u64(3); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_12, __v_23, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_0, __v_40, __v_43, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_47]; - record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained); + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_230] = [__v_47]; + record.function_queries[230].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_229: usize = 4; -const IN_229: usize = 4; -const OUT_229: usize = 1; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_231: usize = 4; +const IN_231: usize = 4; +const OUT_231: usize = 1; +fn aiur_fn_231( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_229], ExecError> { +) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(231); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_229] = [__v_1]; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_231] = [__v_1]; + record.function_queries[231].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(3); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_8, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_229] = [__v_23]; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_231] = [__v_23]; + record.function_queries[231].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21963,35 +22646,36 @@ fn aiur_fn_229( }) } -const INPUT_SIZE_230: usize = 2; -const IN_230: usize = 2; -const OUT_230: usize = 1; -fn aiur_fn_230( - inp: [G; IN_230], +const INPUT_SIZE_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 1; +fn aiur_fn_232( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_230], 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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(232); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -22008,10 +22692,10 @@ fn aiur_fn_230( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_14, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_27: G = __loaded[0]; let __v_28: G = __loaded[1]; let __v_29: G = __loaded[2]; @@ -22019,62 +22703,63 @@ fn aiur_fn_230( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_29, __v_4, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_32, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_32, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_33]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_232] = [__v_33]; + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_33, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_33, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_230] = [__v_34]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_232] = [__v_34]; + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_232] = [__v_0]; + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_232] = [__v_0]; + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_230] = [__v_0]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_232] = [__v_0]; + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_231: usize = 2; -const IN_231: usize = 2; -const OUT_231: usize = 1; -fn aiur_fn_231( - inp: [G; IN_231], +const INPUT_SIZE_233: usize = 2; +const IN_233: usize = 2; +const OUT_233: usize = 1; +fn aiur_fn_233( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_231], ExecError> { +) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(233); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -22083,87 +22768,82 @@ fn aiur_fn_231( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[230].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i)?; } record.function_queries[230].output_at(__i).to_array::() }, _ => aiur_fn_230(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_231] = [__v_7]; - record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_233] = [__v_7]; + record.function_queries[233].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_231] = [__v_0]; - record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_233] = [__v_0]; + record.function_queries[233].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_231] = [__v_0]; - record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_233] = [__v_0]; + record.function_queries[233].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_232: usize = 1; -const IN_232: usize = 1; -const OUT_232: usize = 4; -fn aiur_fn_232( - inp: [G; IN_232], +const INPUT_SIZE_234: usize = 1; +const IN_234: usize = 1; +const OUT_234: usize = 4; +fn aiur_fn_234( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_232], ExecError> { +) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_2: G = __r_arr[0]; - let __v_3: G = __r_arr[1]; - let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = __r_arr[1]; - let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_232] = [__v_2, __v_5, __v_8, __v_11]; - record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained); + record.checkpoint(234); + let __v_0: G = inp.values()[0]; + let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); + let __v_1: G = G::from_u8(__gb[0]); + let __v_2: G = G::from_u8(__gb[1]); + let __v_3: G = G::from_u8(__gb[2]); + let __v_4: G = G::from_u8(__gb[3]); + let __v_5: G = G::from_u8(__gb[4]); + let __v_6: G = G::from_u8(__gb[5]); + let __v_7: G = G::from_u8(__gb[6]); + let __v_8: G = G::from_u8(__gb[7]); + let __ret: [G; OUT_234] = [__v_1, __v_2, __v_3, __v_4]; + record.function_queries[234].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_233: usize = 1; -const IN_233: usize = 1; -const OUT_233: usize = 1; -fn aiur_fn_233( - inp: [G; IN_233], +const INPUT_SIZE_235: usize = 1; +const IN_235: usize = 1; +const OUT_235: usize = 1; +fn aiur_fn_235( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_233], ExecError> { +) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = true; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + record.checkpoint(235); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; let __v_4: G = __r_arr[3]; let __v_5: G = G::from_u64(0); - let __v_6: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; + let __v_6: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record)? }; let __v_7: G = G::from_u64(0); - let __v_8: G = if unconstrained { Bytes2::xor(&__v_2, &__v_7) } else { bytes2_xor_value(__v_2, __v_7, record) }; + let __v_8: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_7)?; Bytes2::xor(&__v_2, &__v_7) } else { bytes2_xor_value(__v_2, __v_7, record)? }; let __v_9: G = G::from_u64(0); - let __v_10: G = if unconstrained { Bytes2::xor(&__v_3, &__v_9) } else { bytes2_xor_value(__v_3, __v_9, record) }; + let __v_10: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_9)?; Bytes2::xor(&__v_3, &__v_9) } else { bytes2_xor_value(__v_3, __v_9, record)? }; let __v_11: G = G::from_u64(0); - let __v_12: G = if unconstrained { Bytes2::xor(&__v_4, &__v_11) } else { bytes2_xor_value(__v_4, __v_11, record) }; + let __v_12: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_11)?; Bytes2::xor(&__v_4, &__v_11) } else { bytes2_xor_value(__v_4, __v_11, record)? }; let __v_13: G = G::from_u64(256); let __v_14: G = (__v_13 * __v_8); let __v_15: G = G::from_u64(65536); @@ -22183,93 +22863,94 @@ fn aiur_fn_233( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_233] = [__v_31]; - record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_235] = [__v_31]; + record.function_queries[235].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_234: usize = 2; -const IN_234: usize = 2; -const OUT_234: usize = 2; -fn aiur_fn_234( - inp: [G; IN_234], +const INPUT_SIZE_236: usize = 2; +const IN_236: usize = 2; +const OUT_236: usize = 2; +fn aiur_fn_236( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_234], 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_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(236); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[212].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[212].bump_multiplicity(__i)?; } record.function_queries[212].output_at(__i).to_array::() }, _ => aiur_fn_212(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_12, __v_15]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_236] = [__v_12, __v_15]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_12, __v_15]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_236] = [__v_12, __v_15]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_13, __v_16]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_236] = [__v_13, __v_16]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_15, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[237].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i)?; } record.function_queries[237].output_at(__i).to_array::() }, _ => aiur_fn_237(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -22277,31 +22958,31 @@ fn aiur_fn_234( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_18, __v_21]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_236] = [__v_18, __v_21]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_19, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_19, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[236].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i)?; } record.function_queries[236].output_at(__i).to_array::() }, _ => aiur_fn_236(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_234] = [__v_22, __v_21]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_236] = [__v_22, __v_21]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_17, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_17, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[242].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i)?; } record.function_queries[242].output_at(__i).to_array::() }, _ => aiur_fn_242(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_22, __v_23]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_236] = [__v_22, __v_23]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -22318,9 +22999,9 @@ fn aiur_fn_234( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_14, __v_17]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_236] = [__v_14, __v_17]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22333,90 +23014,92 @@ fn aiur_fn_234( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_9, __v_12]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_236] = [__v_9, __v_12]; + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_235: usize = 2; -const IN_235: usize = 2; -const OUT_235: usize = 2; -fn aiur_fn_235( - inp: [G; IN_235], +const INPUT_SIZE_237: usize = 2; +const IN_237: usize = 2; +const OUT_237: usize = 2; +fn aiur_fn_237( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_235], ExecError> { +) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + record.checkpoint(237); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[238].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i)?; } record.function_queries[238].output_at(__i).to_array::() }, _ => aiur_fn_238(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_235] = [__v_4, __v_3]; - record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_237] = [__v_4, __v_3]; + record.function_queries[237].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[238].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i)?; } record.function_queries[238].output_at(__i).to_array::() }, _ => aiur_fn_238(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_235] = [__v_5, __v_6]; - record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_237] = [__v_5, __v_6]; + record.function_queries[237].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_236: usize = 1; -const IN_236: usize = 1; -const OUT_236: usize = 2; -fn aiur_fn_236( - inp: [G; IN_236], +const INPUT_SIZE_238: usize = 1; +const IN_238: usize = 1; +const OUT_238: usize = 2; +fn aiur_fn_238( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_236], ExecError> { +) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(238); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_11, __v_12]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_238] = [__v_11, __v_12]; + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -22425,18 +23108,18 @@ fn aiur_fn_236( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_236] = [__v_15, __v_16]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_238] = [__v_15, __v_16]; + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_15, __v_16]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_238] = [__v_15, __v_16]; + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22444,8 +23127,8 @@ fn aiur_fn_236( _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_15, __v_16]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_238] = [__v_15, __v_16]; + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22455,8 +23138,8 @@ fn aiur_fn_236( _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_9, __v_10]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_238] = [__v_9, __v_10]; + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22464,26 +23147,27 @@ fn aiur_fn_236( _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_236] = [__v_5, __v_6]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_238] = [__v_5, __v_6]; + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_237: usize = 1; -const IN_237: usize = 1; -const OUT_237: usize = 2; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_239: usize = 1; +const IN_239: usize = 1; +const OUT_239: usize = 2; +fn aiur_fn_239( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_237], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(239); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -22496,7 +23180,7 @@ fn aiur_fn_237( let __v_10: G = __loaded[9]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -22518,8 +23202,8 @@ fn aiur_fn_237( 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_26, __v_27]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_26, __v_27]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -22530,40 +23214,40 @@ fn aiur_fn_237( let __v_30: G = (__v_27 + __v_29); let __v_31: G = (__v_2 + __v_30); let __v_32: G = G::from_u64(55296); - let __v_33: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_32.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_33: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_32.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_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_34, __v_31]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_34, __v_31]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_34: G = G::from_u64(57343); - let __v_35: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_31.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_35: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_31.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_35.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_36, __v_37]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_36, __v_37]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(1114112); - let __v_37: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_36.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_37: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_36.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); - let __ret: [G; OUT_237] = [__v_38, __v_31]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_38, __v_31]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_38, __v_39]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_38, __v_39]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22577,8 +23261,8 @@ fn aiur_fn_237( _ => { let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_21, __v_22]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_21, __v_22]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22586,32 +23270,33 @@ fn aiur_fn_237( _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_237] = [__v_11, __v_12]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_239] = [__v_11, __v_12]; + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_238: usize = 2; -const IN_238: usize = 2; -const OUT_238: usize = 2; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_240: usize = 2; +const IN_240: usize = 2; +const OUT_240: usize = 2; +fn aiur_fn_240( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_238], 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]; + record.checkpoint(240); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(64); - let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_238] = [__v_0, __v_1]; - record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_240] = [__v_0, __v_1]; + record.function_queries[240].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -22619,91 +23304,93 @@ fn aiur_fn_238( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[240].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i)?; } record.function_queries[240].output_at(__i).to_array::() }, _ => aiur_fn_240(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_238] = [__v_8, __v_9]; - record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_240] = [__v_8, __v_9]; + record.function_queries[240].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 4; -fn aiur_fn_239( - inp: [G; IN_239], +const INPUT_SIZE_241: usize = 1; +const IN_241: usize = 1; +const OUT_241: usize = 4; +fn aiur_fn_241( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_239], ExecError> { +) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(241); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[240].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i)?; } record.function_queries[240].output_at(__i).to_array::() }, _ => aiur_fn_240(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[240].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i)?; } record.function_queries[240].output_at(__i).to_array::() }, _ => aiur_fn_240(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[240].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i)?; } record.function_queries[240].output_at(__i).to_array::() }, _ => aiur_fn_240(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_239] = [__v_2, __v_5, __v_8, __v_9]; - record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_241] = [__v_2, __v_5, __v_8, __v_9]; + record.function_queries[241].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_240: usize = 2; -const IN_240: usize = 2; -const OUT_240: usize = 1; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_242: usize = 2; +const IN_242: usize = 2; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_240], ExecError> { +) -> 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]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = true; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + record.checkpoint(242); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[241].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[241].output_at(__i).to_array::() }, _ => aiur_fn_241(__key, 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 = G::from_u64(0); - let __v_7: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; + let __v_7: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record)? }; let __v_8: G = G::from_u64(0); - let __v_9: G = if unconstrained { Bytes2::xor(&__v_3, &__v_8) } else { bytes2_xor_value(__v_3, __v_8, record) }; + let __v_9: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_8)?; Bytes2::xor(&__v_3, &__v_8) } else { bytes2_xor_value(__v_3, __v_8, record)? }; let __v_10: G = G::from_u64(0); - let __v_11: G = if unconstrained { Bytes2::xor(&__v_4, &__v_10) } else { bytes2_xor_value(__v_4, __v_10, record) }; + let __v_11: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_10)?; Bytes2::xor(&__v_4, &__v_10) } else { bytes2_xor_value(__v_4, __v_10, record)? }; let __v_12: G = G::from_u64(0); - let __v_13: G = if unconstrained { Bytes2::xor(&__v_5, &__v_12) } else { bytes2_xor_value(__v_5, __v_12, record) }; + let __v_13: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_12)?; Bytes2::xor(&__v_5, &__v_12) } else { bytes2_xor_value(__v_5, __v_12, record)? }; let __v_14: G = G::from_u64(64); - let __v_15: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_14.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_15: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_14.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_16: G = G::from_u64(1); if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("utf8 group 0 is not a 6-bit value".to_string()) }); } let __v_17: G = G::from_u64(64); - let __v_18: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_17.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_18: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_17.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_19: G = G::from_u64(1); if (__v_18 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("utf8 group 1 is not a 6-bit value".to_string()) }); } let __v_20: G = G::from_u64(64); - let __v_21: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_20.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_21: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_20.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_22: G = G::from_u64(1); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: Some("utf8 group 2 is not a 6-bit value".to_string()) }); } let __v_23: G = G::from_u64(64); - let __v_24: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_23.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_24: G = { let __a_val = __v_13.as_canonical_u64(); let __b_val = __v_23.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_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("utf8 group 3 is not a 6-bit value".to_string()) }); @@ -22721,18 +23408,18 @@ fn aiur_fn_240( return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("utf8 groups do not recompose to the codepoint".to_string()) }); } let __v_35: G = G::from_u64(128); - let __v_36: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_36: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_36.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_38]; - record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained); + let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_242] = [__v_38]; + record.function_queries[242].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(2048); - let __v_38: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_37.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_38: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_37.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_38.as_canonical_u64() { 1u64 => { let __v_39: G = G::from_u64(128); @@ -22741,15 +23428,15 @@ fn aiur_fn_240( let __v_42: G = (__v_9 + __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_46]; - record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained); + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_242] = [__v_46]; + record.function_queries[242].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_39: G = G::from_u64(65536); - let __v_40: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_39.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_40: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_39.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_40.as_canonical_u64() { 1u64 => { let __v_41: G = G::from_u64(128); @@ -22761,11 +23448,11 @@ fn aiur_fn_240( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_52]; - record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained); + let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_242] = [__v_52]; + record.function_queries[242].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -22781,12 +23468,12 @@ fn aiur_fn_240( let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_240] = [__v_56]; - record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained); + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_42, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_242] = [__v_56]; + record.function_queries[242].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -22797,212 +23484,213 @@ fn aiur_fn_240( }) } -const INPUT_SIZE_241: usize = 1; -const IN_241: usize = 1; -const OUT_241: usize = 1; -fn aiur_fn_241( - inp: [G; IN_241], +const INPUT_SIZE_243: usize = 1; +const IN_243: usize = 1; +const OUT_243: usize = 1; +fn aiur_fn_243( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_241], ExecError> { +) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + record.checkpoint(243); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_3]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_3]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_5]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_5]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_7]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_7]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_9]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_9]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_11]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_11]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_13]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_13]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_15]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_15]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_17]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_17]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_19]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_19]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[176].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i)?; } record.function_queries[176].output_at(__i).to_array::() }, _ => aiur_fn_176(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_21]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_21]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_23]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_23]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_25]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_25]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_27]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_27]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[173].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i)?; } record.function_queries[173].output_at(__i).to_array::() }, _ => aiur_fn_173(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_29]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_29]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_31]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_31]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[175].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i)?; } record.function_queries[175].output_at(__i).to_array::() }, _ => aiur_fn_175(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); - let __ret: [G; OUT_241] = [__v_33]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_33]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_241] = [__v_33]; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_243] = [__v_33]; + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23039,56 +23727,57 @@ fn aiur_fn_241( }) } -const INPUT_SIZE_242: usize = 1; -const IN_242: usize = 1; -const OUT_242: usize = 1; -fn aiur_fn_242( - inp: [G; IN_242], +const INPUT_SIZE_244: usize = 1; +const IN_244: usize = 1; +const OUT_244: usize = 1; +fn aiur_fn_244( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_242], ExecError> { +) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; + record.checkpoint(244); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[157].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i)?; } record.function_queries[157].output_at(__i).to_array::() }, _ => aiur_fn_157(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[159].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i)?; } record.function_queries[159].output_at(__i).to_array::() }, _ => aiur_fn_159(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[160].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i)?; } record.function_queries[160].output_at(__i).to_array::() }, _ => aiur_fn_160(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[163].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i)?; } record.function_queries[163].output_at(__i).to_array::() }, _ => aiur_fn_163(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_18 + __v_20); let __v_22: G = (__v_16 + __v_21); @@ -23099,24 +23788,25 @@ fn aiur_fn_242( let __v_27: G = (__v_6 + __v_26); let __v_28: G = (__v_4 + __v_27); let __v_29: G = (__v_2 + __v_28); - let __ret: [G; OUT_242] = [__v_29]; - record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_244] = [__v_29]; + record.function_queries[244].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_243: usize = 1; -const IN_243: usize = 1; -const OUT_243: usize = 2; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_245: usize = 1; +const IN_245: usize = 1; +const OUT_245: usize = 2; +fn aiur_fn_245( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_243], ExecError> { +) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(245); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -23126,112 +23816,113 @@ fn aiur_fn_243( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_243] = [__v_5, __v_3]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_245] = [__v_5, __v_3]; + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_5, __v_8]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_245] = [__v_5, __v_8]; + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[149].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i)?; } record.function_queries[149].output_at(__i).to_array::() }, _ => aiur_fn_149(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_7, __v_10]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_245] = [__v_7, __v_10]; + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_7, __v_10]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_245] = [__v_7, __v_10]; + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_243] = [__v_5, __v_6]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_245] = [__v_5, __v_6]; + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_243] = [__v_5, __v_8]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_245] = [__v_5, __v_8]; + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_244: usize = 2; -const IN_244: usize = 2; -const OUT_244: usize = 2; -fn aiur_fn_244( - inp: [G; IN_244], +const INPUT_SIZE_246: usize = 2; +const IN_246: usize = 2; +const OUT_246: usize = 2; +fn aiur_fn_246( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_244], ExecError> { +) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(246); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_244] = [__v_10, __v_11]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_246] = [__v_10, __v_11]; + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_10, __v_13]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_246] = [__v_10, __v_13]; + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23240,9 +23931,9 @@ fn aiur_fn_244( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_8, __v_11]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_246] = [__v_8, __v_11]; + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23251,95 +23942,97 @@ fn aiur_fn_244( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_244] = [__v_6, __v_9]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_246] = [__v_6, __v_9]; + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_245: usize = 1; -const IN_245: usize = 1; -const OUT_245: usize = 1; -fn aiur_fn_245( - inp: [G; IN_245], +const INPUT_SIZE_247: usize = 1; +const IN_247: usize = 1; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_245], ExecError> { +) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(247); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(7); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_245] = [__v_4]; - record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained); + let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_247] = [__v_4]; + record.function_queries[247].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_246: usize = 1; -const IN_246: usize = 1; -const OUT_246: usize = 3; -fn aiur_fn_246( - inp: [G; IN_246], +const INPUT_SIZE_248: usize = 1; +const IN_248: usize = 1; +const OUT_248: usize = 3; +fn aiur_fn_248( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_246], ExecError> { +) -> Result<[G; OUT_248], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(248); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_13, __v_14, __v_15]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_248] = [__v_13, __v_14, __v_15]; + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_15, __v_16, __v_18]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_248] = [__v_15, __v_16, __v_18]; + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -23347,9 +24040,9 @@ fn aiur_fn_246( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_15, __v_16, __v_19]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_248] = [__v_15, __v_16, __v_19]; + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23361,9 +24054,9 @@ fn aiur_fn_246( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_11, __v_12, __v_15]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_248] = [__v_11, __v_12, __v_15]; + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23373,9 +24066,9 @@ fn aiur_fn_246( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_9, __v_10, __v_13]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_248] = [__v_9, __v_10, __v_13]; + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23385,42 +24078,43 @@ fn aiur_fn_246( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_246] = [__v_5, __v_6, __v_9]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_248] = [__v_5, __v_6, __v_9]; + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_247: usize = 2; -const IN_247: usize = 2; -const OUT_247: usize = 1; -fn aiur_fn_247( - inp: [G; IN_247], +const INPUT_SIZE_249: usize = 2; +const IN_249: usize = 2; +const OUT_249: usize = 1; +fn aiur_fn_249( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_247], ExecError> { +) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + record.checkpoint(249); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); let __v_6: G = (__v_0 * __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -23432,9 +24126,9 @@ fn aiur_fn_247( break '__mc_1 [__v_2]; }, _ => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[127].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i)?; } record.function_queries[127].output_at(__i).to_array::() }, _ => aiur_fn_127(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_1 [__v_9]; }, @@ -23445,64 +24139,65 @@ fn aiur_fn_247( let __v_10: G = G::from_u64(2); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_247] = [__v_18]; - record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_249] = [__v_18]; + record.function_queries[249].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_248: usize = 4; -const IN_248: usize = 4; -const OUT_248: usize = 1; -fn aiur_fn_248( - inp: [G; IN_248], +const INPUT_SIZE_250: usize = 4; +const IN_250: usize = 4; +const OUT_250: usize = 1; +fn aiur_fn_250( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_248], ExecError> { +) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(250); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 - __v_2); match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_6]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_250] = [__v_6]; + record.function_queries[250].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_7]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_250] = [__v_7]; + record.function_queries[250].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_248] = [__v_7]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_250] = [__v_7]; + record.function_queries[250].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23511,54 +24206,55 @@ fn aiur_fn_248( }) } -const INPUT_SIZE_249: usize = 3; -const IN_249: usize = 3; -const OUT_249: usize = 1; -fn aiur_fn_249( - inp: [G; IN_249], +const INPUT_SIZE_251: usize = 3; +const IN_251: usize = 3; +const OUT_251: usize = 1; +fn aiur_fn_251( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_249], ExecError> { +) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(251); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_4]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_251] = [__v_4]; + record.function_queries[251].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_11]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_251] = [__v_11]; + record.function_queries[251].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_9, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_249] = [__v_10]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_251] = [__v_10]; + record.function_queries[251].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23567,47 +24263,48 @@ fn aiur_fn_249( }) } -const INPUT_SIZE_250: usize = 4; -const IN_250: usize = 4; -const OUT_250: usize = 1; -fn aiur_fn_250( - inp: [G; IN_250], +const INPUT_SIZE_252: usize = 4; +const IN_252: usize = 4; +const OUT_252: usize = 1; +fn aiur_fn_252( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_250], ExecError> { +) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(252); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_9]; - record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_252] = [__v_9]; + record.function_queries[252].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_0 * __v_9); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -23623,54 +24320,55 @@ fn aiur_fn_250( let __v_15: G = (__v_2 - __v_14); let __v_16: G = (__v_0 + __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); let __v_20: G = (__v_16 * __v_19); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_20, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_20, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_21]; - record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_252] = [__v_21]; + record.function_queries[252].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_251: usize = 3; -const IN_251: usize = 3; -const OUT_251: usize = 1; -fn aiur_fn_251( - inp: [G; IN_251], +const INPUT_SIZE_253: usize = 3; +const IN_253: usize = 3; +const OUT_253: usize = 1; +fn aiur_fn_253( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_251], ExecError> { +) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(253); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_4]; - record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_253] = [__v_4]; + record.function_queries[253].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23691,31 +24389,31 @@ fn aiur_fn_251( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_23, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_23, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_24, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_24, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; match __v_25.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_28]; - record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_253] = [__v_28]; + record.function_queries[253].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_26, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_251] = [__v_27]; - record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_253] = [__v_27]; + record.function_queries[253].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23724,44 +24422,45 @@ fn aiur_fn_251( }) } -const INPUT_SIZE_252: usize = 3; -const IN_252: usize = 3; -const OUT_252: usize = 1; -fn aiur_fn_252( - inp: [G; IN_252], +const INPUT_SIZE_254: usize = 3; +const IN_254: usize = 3; +const OUT_254: usize = 1; +fn aiur_fn_254( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_252], ExecError> { +) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(254); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_8]; - record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_254] = [__v_8]; + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); let __v_8: G = (__v_0 * __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; break '__mc_0 [__v_9]; }, @@ -23771,16 +24470,16 @@ fn aiur_fn_252( } }; let __v_9: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_0 * __v_13); let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; break '__mc_1 [__v_15]; }, @@ -23791,7 +24490,7 @@ fn aiur_fn_252( }; let __v_15: G = __mc_out___mc_1[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = (__v_0 * __v_18); @@ -23806,20 +24505,20 @@ fn aiur_fn_252( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_33, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_34, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_34, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_19, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_36]; - record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_254] = [__v_36]; + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -23835,12 +24534,12 @@ fn aiur_fn_252( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); - let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_19, __v_15, __v_36, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_252] = [__v_50]; - record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_254] = [__v_50]; + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23849,64 +24548,65 @@ fn aiur_fn_252( }) } -const INPUT_SIZE_253: usize = 3; -const IN_253: usize = 3; -const OUT_253: usize = 2; -fn aiur_fn_253( - inp: [G; IN_253], +const INPUT_SIZE_255: usize = 3; +const IN_255: usize = 3; +const OUT_255: usize = 2; +fn aiur_fn_255( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_253], ExecError> { +) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + record.checkpoint(255); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[157].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i)?; } record.function_queries[157].output_at(__i).to_array::() }, _ => aiur_fn_157(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_6 + __v_8); match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __v_11: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_11: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_11.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_12, __v_16]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_255] = [__v_12, __v_16]; + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_0 [__v_19]; }, @@ -23914,11 +24614,11 @@ fn aiur_fn_253( let __v_19: G = G::from_u64(1); let __v_20: G = (__v_19 - __v_15); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = (__v_20 * __v_23); - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_24, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_24, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_0 [__v_25]; }, @@ -23927,12 +24627,12 @@ fn aiur_fn_253( let __v_19: G = __mc_out___mc_0[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_19, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_253] = [__v_20, __v_23]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_255] = [__v_20, __v_23]; + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -23940,9 +24640,9 @@ fn aiur_fn_253( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_17, __v_21]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_255] = [__v_17, __v_21]; + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23951,33 +24651,33 @@ fn aiur_fn_253( }, _ => { let __v_10: G = G::from_u64(2); - let __v_11: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_11: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_11.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_12, __v_16]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_255] = [__v_12, __v_16]; + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_3, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_253] = [__v_17, __v_18]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_255] = [__v_17, __v_18]; + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -23985,9 +24685,9 @@ fn aiur_fn_253( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_253] = [__v_17, __v_21]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_255] = [__v_17, __v_21]; + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23998,62 +24698,63 @@ fn aiur_fn_253( }) } -const INPUT_SIZE_254: usize = 4; -const IN_254: usize = 4; -const OUT_254: usize = 2; -fn aiur_fn_254( - inp: [G; IN_254], +const INPUT_SIZE_256: usize = 4; +const IN_256: usize = 4; +const OUT_256: usize = 2; +fn aiur_fn_256( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_254], ExecError> { +) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + record.checkpoint(256); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[160].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i)?; } record.function_queries[160].output_at(__i).to_array::() }, _ => aiur_fn_160(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[163].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i)?; } record.function_queries[163].output_at(__i).to_array::() }, _ => aiur_fn_163(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = (__v_5 + __v_10); match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[160].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i)?; } record.function_queries[160].output_at(__i).to_array::() }, _ => aiur_fn_160(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; break '__mc_0 [__v_18]; }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; break '__mc_0 [__v_20]; }, @@ -24069,18 +24770,18 @@ fn aiur_fn_254( let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_33: G = G::from_u64(1); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_15, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_33 - __v_35); let __v_37: G = (__v_2 * __v_36); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; break '__mc_0 [__v_39]; }, @@ -24091,12 +24792,12 @@ fn aiur_fn_254( let __v_18: G = __mc_out___mc_0[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_18, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_254] = [__v_19, __v_22]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_256] = [__v_19, __v_22]; + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24104,55 +24805,55 @@ fn aiur_fn_254( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_16, __v_20]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_256] = [__v_16, __v_20]; + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; match __v_14.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; break '__mc_1 [__v_19]; }, _ => { - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = (__v_21 - __v_15); let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_23 - __v_24); let __v_26: G = (__v_22 * __v_25); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_26, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; break '__mc_1 [__v_27]; }, _ => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -24162,34 +24863,34 @@ fn aiur_fn_254( let __v_26: G = (__v_15 - __v_25); let __v_27: G = (__v_2 + __v_26); let __v_28: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 * __v_33); let __v_35: G = (__v_27 * __v_34); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_35, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; break '__mc_1 [__v_37]; }, _ => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[251].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i)?; } record.function_queries[251].output_at(__i).to_array::() }, _ => aiur_fn_251(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; break '__mc_1 [__v_25]; }, @@ -24204,12 +24905,12 @@ fn aiur_fn_254( let __v_19: G = __mc_out___mc_1[0]; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_19, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_254] = [__v_20, __v_23]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_256] = [__v_20, __v_23]; + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24217,9 +24918,9 @@ fn aiur_fn_254( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_254] = [__v_17, __v_21]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_256] = [__v_17, __v_21]; + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24228,36 +24929,37 @@ fn aiur_fn_254( }) } -const INPUT_SIZE_255: usize = 2; -const IN_255: usize = 2; -const OUT_255: usize = 1; -fn aiur_fn_255( - inp: [G; IN_255], +const INPUT_SIZE_257: usize = 2; +const IN_257: usize = 2; +const OUT_257: usize = 1; +fn aiur_fn_257( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_255], ExecError> { +) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(257); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_255] = [__v_0]; - record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_257] = [__v_0]; + record.function_queries[257].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_7, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_255] = [__v_8]; - record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_257] = [__v_8]; + record.function_queries[257].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24267,264 +24969,265 @@ fn aiur_fn_255( }) } -const INPUT_SIZE_256: usize = 3; -const IN_256: usize = 3; -const OUT_256: usize = 2; -fn aiur_fn_256( - inp: [G; IN_256], +const INPUT_SIZE_258: usize = 3; +const IN_258: usize = 3; +const OUT_258: usize = 2; +fn aiur_fn_258( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_256], ExecError> { +) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + record.checkpoint(258); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_5, __v_8]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_5, __v_8]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_7, __v_10]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_7, __v_10]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_9, __v_12]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_9, __v_12]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_11, __v_14]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_11, __v_14]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_13, __v_16]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_13, __v_16]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[139].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i)?; } record.function_queries[139].output_at(__i).to_array::() }, _ => aiur_fn_139(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_15, __v_18]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_15, __v_18]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_17, __v_20]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_17, __v_20]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_19, __v_22]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_19, __v_22]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[145].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[145].bump_multiplicity(__i)?; } record.function_queries[145].output_at(__i).to_array::() }, _ => aiur_fn_145(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_21, __v_24]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_21, __v_24]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[173].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i)?; } record.function_queries[173].output_at(__i).to_array::() }, _ => aiur_fn_173(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[146].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[146].bump_multiplicity(__i)?; } record.function_queries[146].output_at(__i).to_array::() }, _ => aiur_fn_146(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_23, __v_26]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_23, __v_26]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[147].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i)?; } record.function_queries[147].output_at(__i).to_array::() }, _ => aiur_fn_147(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_25, __v_28]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_25, __v_28]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[175].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i)?; } record.function_queries[175].output_at(__i).to_array::() }, _ => aiur_fn_175(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[148].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i)?; } record.function_queries[148].output_at(__i).to_array::() }, _ => aiur_fn_148(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_27, __v_30]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_27, __v_30]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[176].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i)?; } record.function_queries[176].output_at(__i).to_array::() }, _ => aiur_fn_176(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[340].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i)?; } record.function_queries[340].output_at(__i).to_array::() }, _ => aiur_fn_340(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_29, __v_31]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_29, __v_31]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_256] = [__v_31, __v_33]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_258] = [__v_31, __v_33]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -24532,9 +25235,9 @@ fn aiur_fn_256( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_256] = [__v_31, __v_35]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_258] = [__v_31, __v_35]; + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24567,53 +25270,54 @@ fn aiur_fn_256( }) } -const INPUT_SIZE_257: usize = 2; -const IN_257: usize = 2; -const OUT_257: usize = 3; -fn aiur_fn_257( - inp: [G; IN_257], +const INPUT_SIZE_259: usize = 2; +const IN_259: usize = 2; +const OUT_259: usize = 3; +fn aiur_fn_259( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_257], ExecError> { +) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(259); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_8, __v_0, __v_11]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_259] = [__v_8, __v_0, __v_11]; + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -24623,17 +25327,17 @@ fn aiur_fn_257( match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_257] = [__v_19, __v_12, __v_17]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_259] = [__v_19, __v_12, __v_17]; + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_259] = [__v_19, __v_0, __v_22]; + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24642,9 +25346,9 @@ fn aiur_fn_257( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_259] = [__v_19, __v_0, __v_22]; + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24653,9 +25357,9 @@ fn aiur_fn_257( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_11, __v_0, __v_14]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_259] = [__v_11, __v_0, __v_14]; + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24666,27 +25370,28 @@ fn aiur_fn_257( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_257] = [__v_6, __v_0, __v_9]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_259] = [__v_6, __v_0, __v_9]; + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_258: usize = 2; -const IN_258: usize = 2; -const OUT_258: usize = 1; -fn aiur_fn_258( - inp: [G; IN_258], +const INPUT_SIZE_260: usize = 2; +const IN_260: usize = 2; +const OUT_260: usize = 1; +fn aiur_fn_260( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_258], ExecError> { +) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(260); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(0); @@ -24698,129 +25403,130 @@ fn aiur_fn_258( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_1, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_27]; - record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_260] = [__v_27]; + record.function_queries[260].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_30: G = G::from_u64(0); - let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_25, __v_26, __v_29, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(7); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_16, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_36: G = G::from_u64(3); let __v_37: G = G::from_u64(3); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 4] = [__v_37, __v_31, __v_0, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_39, __v_35, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_44]; - record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained); + let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_260] = [__v_44]; + record.function_queries[260].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_259: usize = 1; -const IN_259: usize = 1; -const OUT_259: usize = 1; -fn aiur_fn_259( - inp: [G; IN_259], +const INPUT_SIZE_261: usize = 1; +const IN_261: usize = 1; +const OUT_261: usize = 1; +fn aiur_fn_261( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_259], ExecError> { +) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(261); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 7u64 => { - let __ret: [G; OUT_259] = [__v_0]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_261] = [__v_0]; + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[259].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i)?; } record.function_queries[259].output_at(__i).to_array::() }, _ => aiur_fn_259(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_259] = [__v_0]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_261] = [__v_0]; + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_12, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[260].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i)?; } record.function_queries[260].output_at(__i).to_array::() }, _ => aiur_fn_260(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_16]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_261] = [__v_16]; + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_259] = [__v_0]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_261] = [__v_0]; + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_259] = [__v_0]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_261] = [__v_0]; + record.function_queries[261].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24829,115 +25535,117 @@ fn aiur_fn_259( }) } -const INPUT_SIZE_260: usize = 3; -const IN_260: usize = 3; -const OUT_260: usize = 2; -fn aiur_fn_260( - inp: [G; IN_260], +const INPUT_SIZE_262: usize = 3; +const IN_262: usize = 3; +const OUT_262: usize = 2; +fn aiur_fn_262( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_260], ExecError> { +) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + record.checkpoint(262); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_4, __v_5]; - record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_262] = [__v_4, __v_5]; + record.function_queries[262].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_4, __v_5, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_17, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_260] = [__v_18, __v_19]; - record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_262] = [__v_18, __v_19]; + record.function_queries[262].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_261: usize = 1; -const IN_261: usize = 1; -const OUT_261: usize = 1; -fn aiur_fn_261( - inp: [G; IN_261], +const INPUT_SIZE_263: usize = 1; +const IN_263: usize = 1; +const OUT_263: usize = 1; +fn aiur_fn_263( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_261], ExecError> { +) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(263); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_17]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_17]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_10, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; @@ -24945,22 +25653,22 @@ fn aiur_fn_261( match __v_22.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); - let __ret: [G; OUT_261] = [__v_26]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_26]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_26]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_26]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_20]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_20]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -24969,62 +25677,63 @@ fn aiur_fn_261( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_15]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_15]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_9]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_9]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_261] = [__v_5]; - record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_263] = [__v_5]; + record.function_queries[263].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_262: usize = 5; -const IN_262: usize = 5; -const OUT_262: usize = 2; -fn aiur_fn_262( - inp: [G; IN_262], +const INPUT_SIZE_264: usize = 5; +const IN_264: usize = 5; +const OUT_264: usize = 2; +fn aiur_fn_264( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_262], ExecError> { +) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(264); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(2); - let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_6.as_canonical_u64() { 1u64 => { let __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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_7, __v_11]; - record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_264] = [__v_7, __v_11]; + record.function_queries[264].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -25033,18 +25742,18 @@ fn aiur_fn_262( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_10, __v_14]; - record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_264] = [__v_10, __v_14]; + record.function_queries[264].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[261].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[263].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[263].bump_multiplicity(__i)?; } record.function_queries[263].output_at(__i).to_array::() }, _ => aiur_fn_263(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -25052,40 +25761,40 @@ fn aiur_fn_262( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_262] = [__v_15, __v_19]; - record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_264] = [__v_15, __v_19]; + record.function_queries[264].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_20, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_23, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_262] = [__v_21, __v_24]; - record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_264] = [__v_21, __v_24]; + record.function_queries[264].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_15, __v_9, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[262].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[262].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[262].bump_multiplicity(__i)?; } record.function_queries[262].output_at(__i).to_array::() }, _ => aiur_fn_262(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_262] = [__v_21, __v_22]; - record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_264] = [__v_21, __v_22]; + record.function_queries[264].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25101,65 +25810,66 @@ fn aiur_fn_262( }) } -const INPUT_SIZE_263: usize = 3; -const IN_263: usize = 3; -const OUT_263: usize = 2; -fn aiur_fn_263( - inp: [G; IN_263], +const INPUT_SIZE_265: usize = 3; +const IN_265: usize = 3; +const OUT_265: usize = 2; +fn aiur_fn_265( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_263], ExecError> { +) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(265); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_10, __v_14]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_265] = [__v_10, __v_14]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_18, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_263] = [__v_16, __v_19]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_265] = [__v_16, __v_19]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25167,9 +25877,9 @@ fn aiur_fn_263( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_14, __v_18]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_265] = [__v_14, __v_18]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25180,41 +25890,41 @@ fn aiur_fn_263( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_10, __v_14]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_265] = [__v_10, __v_14]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[127].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i)?; } record.function_queries[127].output_at(__i).to_array::() }, _ => aiur_fn_127(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_19, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_263] = [__v_16, __v_20]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_265] = [__v_16, __v_20]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25222,9 +25932,9 @@ fn aiur_fn_263( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_263] = [__v_14, __v_18]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_265] = [__v_14, __v_18]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25232,11 +25942,11 @@ fn aiur_fn_263( } }, _ => { - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[266].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[266].bump_multiplicity(__i)?; } record.function_queries[266].output_at(__i).to_array::() }, _ => aiur_fn_266(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_263] = [__v_8, __v_9]; - record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_265] = [__v_8, __v_9]; + record.function_queries[265].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25245,62 +25955,63 @@ fn aiur_fn_263( }) } -const INPUT_SIZE_264: usize = 3; -const IN_264: usize = 3; -const OUT_264: usize = 2; -fn aiur_fn_264( - inp: [G; IN_264], +const INPUT_SIZE_266: usize = 3; +const IN_266: usize = 3; +const OUT_266: usize = 2; +fn aiur_fn_266( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_264], ExecError> { +) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(266); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(2); - let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_5, __v_9]; - record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_266] = [__v_5, __v_9]; + record.function_queries[266].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[258].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i)?; } record.function_queries[258].output_at(__i).to_array::() }, _ => aiur_fn_258(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_14, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_264] = [__v_17, __v_18]; - record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_266] = [__v_17, __v_18]; + record.function_queries[266].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25308,9 +26019,9 @@ fn aiur_fn_264( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_15, __v_19]; - record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_266] = [__v_15, __v_19]; + record.function_queries[266].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25320,24 +26031,24 @@ fn aiur_fn_264( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_13, __v_17]; - record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_266] = [__v_13, __v_17]; + record.function_queries[266].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[265].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[265].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_6, __v_12, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[267].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i)?; } record.function_queries[267].output_at(__i).to_array::() }, _ => aiur_fn_267(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_264] = [__v_13, __v_14]; - record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_266] = [__v_13, __v_14]; + record.function_queries[266].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25345,9 +26056,9 @@ fn aiur_fn_264( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_13, __v_17]; - record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_266] = [__v_13, __v_17]; + record.function_queries[266].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25358,43 +26069,44 @@ fn aiur_fn_264( }) } -const INPUT_SIZE_265: usize = 4; -const IN_265: usize = 4; -const OUT_265: usize = 2; -fn aiur_fn_265( - inp: [G; IN_265], +const INPUT_SIZE_267: usize = 4; +const IN_267: usize = 4; +const OUT_267: usize = 2; +fn aiur_fn_267( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_265], ExecError> { +) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + record.checkpoint(267); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_7 + __v_9); let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_11 - __v_12); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[127].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i)?; } record.function_queries[127].output_at(__i).to_array::() }, _ => aiur_fn_127(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_14 - __v_17); let __v_19: G = (__v_13 * __v_18); @@ -25406,25 +26118,25 @@ fn aiur_fn_265( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_22, __v_26]; - record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained); + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_267] = [__v_22, __v_26]; + record.function_queries[267].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[262].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[262].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[262].bump_multiplicity(__i)?; } record.function_queries[262].output_at(__i).to_array::() }, _ => aiur_fn_262(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); - let __ret: [G; OUT_265] = [__v_26, __v_25]; - record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_267] = [__v_26, __v_25]; + record.function_queries[267].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25432,19 +26144,19 @@ fn aiur_fn_265( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_26, __v_30]; - record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained); + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_29, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_267] = [__v_26, __v_30]; + record.function_queries[267].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[268].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[268].bump_multiplicity(__i)?; } record.function_queries[268].output_at(__i).to_array::() }, _ => aiur_fn_268(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_24, __v_25]; - record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_267] = [__v_24, __v_25]; + record.function_queries[267].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25453,84 +26165,86 @@ fn aiur_fn_265( }) } -const INPUT_SIZE_266: usize = 4; -const IN_266: usize = 4; -const OUT_266: usize = 1; -fn aiur_fn_266( - inp: [G; IN_266], +const INPUT_SIZE_268: usize = 4; +const IN_268: usize = 4; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_266], ExecError> { +) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(268); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(2); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_0, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_16, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_266] = [__v_17]; - record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_268] = [__v_17]; + record.function_queries[268].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_267: usize = 10; -const IN_267: usize = 10; -const OUT_267: usize = 8; -fn aiur_fn_267( - inp: [G; IN_267], +const INPUT_SIZE_269: usize = 10; +const IN_269: usize = 10; +const OUT_269: usize = 8; +fn aiur_fn_269( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_267], ExecError> { +) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(269); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_9.as_canonical_u64() { 8u64 => { - let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25539,13 +26253,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25554,13 +26268,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25569,13 +26283,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25584,13 +26298,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25599,13 +26313,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25614,13 +26328,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25629,13 +26343,13 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25644,8 +26358,8 @@ fn aiur_fn_267( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_269] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[269].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -25659,26 +26373,27 @@ fn aiur_fn_267( }) } -const INPUT_SIZE_268: usize = 2; -const IN_268: usize = 2; -const OUT_268: usize = 1; -fn aiur_fn_268( - inp: [G; IN_268], +const INPUT_SIZE_270: usize = 2; +const IN_270: usize = 2; +const OUT_270: usize = 1; +fn aiur_fn_270( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_268], ExecError> { +) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(270); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_268] = [__v_0]; - record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_270] = [__v_0]; + record.function_queries[270].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -25686,18 +26401,18 @@ fn aiur_fn_268( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_7]; - record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_270] = [__v_7]; + record.function_queries[270].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[270].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i)?; } record.function_queries[270].output_at(__i).to_array::() }, _ => aiur_fn_270(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_268] = [__v_7]; - record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_270] = [__v_7]; + record.function_queries[270].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25709,17 +26424,18 @@ fn aiur_fn_268( }) } -const INPUT_SIZE_269: usize = 1; -const IN_269: usize = 1; -const OUT_269: usize = 1; -fn aiur_fn_269( - inp: [G; IN_269], +const INPUT_SIZE_271: usize = 1; +const IN_271: usize = 1; +const OUT_271: usize = 1; +fn aiur_fn_271( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_269], ExecError> { +) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(271); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); @@ -25729,7 +26445,7 @@ fn aiur_fn_269( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[269].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i)?; } record.function_queries[269].output_at(__i).to_array::() }, _ => aiur_fn_269(__key, 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]; @@ -25739,9 +26455,9 @@ fn aiur_fn_269( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = G::from_u64(8); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[270].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i)?; } record.function_queries[270].output_at(__i).to_array::() }, _ => aiur_fn_270(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -25749,18 +26465,18 @@ fn aiur_fn_269( 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[271].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i)?; } record.function_queries[271].output_at(__i).to_array::() }, _ => aiur_fn_271(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, } }; let __v_23: G = __mc_out___mc_0[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; @@ -25773,25 +26489,25 @@ fn aiur_fn_269( let __v_33: G = __loaded[9]; match __v_24.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; match __v_34.as_canonical_u64() { 1u64 => { let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); - let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_37]; - record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained); + let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_271] = [__v_37]; + record.function_queries[271].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_39]; - record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained); + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_271] = [__v_39]; + record.function_queries[271].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25801,27 +26517,28 @@ fn aiur_fn_269( }, _ => { let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_35]; - record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained); + let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_271] = [__v_35]; + record.function_queries[271].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_270: usize = 1; -const IN_270: usize = 1; -const OUT_270: usize = 1; -fn aiur_fn_270( - inp: [G; IN_270], +const INPUT_SIZE_272: usize = 1; +const IN_272: usize = 1; +const OUT_272: usize = 1; +fn aiur_fn_272( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_270], ExecError> { +) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; + record.checkpoint(272); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<9>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -25835,51 +26552,51 @@ fn aiur_fn_270( 0u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_12]; - record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_272] = [__v_12]; + record.function_queries[272].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_272] = [__v_13]; + record.function_queries[272].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_272] = [__v_13]; + record.function_queries[272].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_272] = [__v_13]; + record.function_queries[272].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_10: G = G::from_u64(4); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_270] = [__v_13]; - record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_272] = [__v_13]; + record.function_queries[272].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25889,19 +26606,20 @@ fn aiur_fn_270( }) } -const INPUT_SIZE_271: usize = 2; -const IN_271: usize = 2; -const OUT_271: usize = 1; -fn aiur_fn_271( - inp: [G; IN_271], +const INPUT_SIZE_273: usize = 2; +const IN_273: usize = 2; +const OUT_273: usize = 1; +fn aiur_fn_273( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_271], ExecError> { +) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(273); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -25916,24 +26634,24 @@ fn aiur_fn_271( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_14]; - record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_273] = [__v_14]; + record.function_queries[273].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[273].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i)?; } record.function_queries[273].output_at(__i).to_array::() }, _ => aiur_fn_273(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_271] = [__v_17]; - record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_273] = [__v_17]; + record.function_queries[273].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -25943,22 +26661,23 @@ fn aiur_fn_271( }) } -const INPUT_SIZE_272: usize = 5; -const IN_272: usize = 5; -const OUT_272: usize = 1; -fn aiur_fn_272( - inp: [G; IN_272], +const INPUT_SIZE_274: usize = 5; +const IN_274: usize = 5; +const OUT_274: usize = 1; +fn aiur_fn_274( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_272], ExecError> { +) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + record.checkpoint(274); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -25979,169 +26698,169 @@ fn aiur_fn_272( let __v_22: G = __loaded[17]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[272].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i)?; } record.function_queries[272].output_at(__i).to_array::() }, _ => aiur_fn_272(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_28]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_26]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_26]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_14, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[273].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i)?; } record.function_queries[273].output_at(__i).to_array::() }, _ => aiur_fn_273(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_28]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_14, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[273].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i)?; } record.function_queries[273].output_at(__i).to_array::() }, _ => aiur_fn_273(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_28]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_28]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_28]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[284].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[286].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[286].bump_multiplicity(__i)?; } record.function_queries[286].output_at(__i).to_array::() }, _ => aiur_fn_286(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[225].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i)?; } record.function_queries[225].output_at(__i).to_array::() }, _ => aiur_fn_225(__key, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_29]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_29]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[284].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[286].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[286].bump_multiplicity(__i)?; } record.function_queries[286].output_at(__i).to_array::() }, _ => aiur_fn_286(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[271].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i)?; } record.function_queries[271].output_at(__i).to_array::() }, _ => aiur_fn_271(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_30]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_30]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_27]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_27]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_27]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_272] = [__v_27]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_274] = [__v_27]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_272] = [__v_28]; - record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_274] = [__v_28]; + record.function_queries[274].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26156,47 +26875,48 @@ fn aiur_fn_272( }) } -const INPUT_SIZE_273: usize = 17; -const IN_273: usize = 17; -const OUT_273: usize = 12; -fn aiur_fn_273( - inp: [G; IN_273], +const INPUT_SIZE_275: usize = 17; +const IN_275: usize = 17; +const OUT_275: usize = 12; +fn aiur_fn_275( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_273], ExecError> { +) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(275); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_275] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + record.function_queries[275].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -26214,15 +26934,15 @@ fn aiur_fn_273( let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_275] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + record.function_queries[275].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_275] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + record.function_queries[275].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26234,98 +26954,101 @@ fn aiur_fn_273( }) } -const INPUT_SIZE_274: usize = 14; -const IN_274: usize = 14; -const OUT_274: usize = 12; -fn aiur_fn_274( - inp: [G; IN_274], +const INPUT_SIZE_276: usize = 14; +const IN_276: usize = 14; +const OUT_276: usize = 12; +fn aiur_fn_276( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_274], ExecError> { +) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(276); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_276] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + record.function_queries[276].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_275: usize = 14; -const IN_275: usize = 14; -const OUT_275: usize = 12; -fn aiur_fn_275( - inp: [G; IN_275], +const INPUT_SIZE_277: usize = 14; +const IN_277: usize = 14; +const OUT_277: usize = 12; +fn aiur_fn_277( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_275], ExecError> { +) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(277); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_277] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + record.function_queries[277].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_276: usize = 1; -const IN_276: usize = 1; -const OUT_276: usize = 1; -fn aiur_fn_276( - inp: [G; IN_276], +const INPUT_SIZE_278: usize = 1; +const IN_278: usize = 1; +const OUT_278: usize = 1; +fn aiur_fn_278( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_276], ExecError> { +) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + record.checkpoint(278); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<36>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26365,17 +27088,17 @@ fn aiur_fn_276( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_37]; - record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_278] = [__v_37]; + record.function_queries[278].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[278].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[278].bump_multiplicity(__i)?; } record.function_queries[278].output_at(__i).to_array::() }, _ => aiur_fn_278(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_276] = [__v_39]; - record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_278] = [__v_39]; + record.function_queries[278].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26385,19 +27108,20 @@ fn aiur_fn_276( }) } -const INPUT_SIZE_277: usize = 2; -const IN_277: usize = 2; -const OUT_277: usize = 34; -fn aiur_fn_277( - inp: [G; IN_277], +const INPUT_SIZE_279: usize = 2; +const IN_279: usize = 2; +const OUT_279: usize = 34; +fn aiur_fn_279( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_277], ExecError> { +) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + record.checkpoint(279); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<36>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -26438,14 +27162,14 @@ fn aiur_fn_277( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_277] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_279] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + record.function_queries[279].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_37, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[279].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[279].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[279].bump_multiplicity(__i)?; } record.function_queries[279].output_at(__i).to_array::() }, _ => aiur_fn_279(__key, 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]; @@ -26480,8 +27204,8 @@ fn aiur_fn_277( let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; - let __ret: [G; OUT_277] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_279] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; + record.function_queries[279].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -26493,160 +27217,163 @@ fn aiur_fn_277( }) } -const INPUT_SIZE_278: usize = 33; -const IN_278: usize = 33; -const OUT_278: usize = 12; -fn aiur_fn_278( - inp: [G; IN_278], +const INPUT_SIZE_280: usize = 33; +const IN_280: usize = 33; +const OUT_280: usize = 12; +fn aiur_fn_280( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_278], ExecError> { +) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; + record.checkpoint(280); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[278].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[278].bump_multiplicity(__i)?; } record.function_queries[278].output_at(__i).to_array::() }, _ => aiur_fn_278(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_278] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_280] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; + record.function_queries[280].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_279: usize = 40; -const IN_279: usize = 40; -const OUT_279: usize = 12; -fn aiur_fn_279( - inp: [G; IN_279], +const INPUT_SIZE_281: usize = 40; +const IN_281: usize = 40; +const OUT_281: usize = 12; +fn aiur_fn_281( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_279], ExecError> { +) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; + record.checkpoint(281); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_279] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - record.function_queries[279].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_281] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + record.function_queries[281].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_280: usize = 6; -const IN_280: usize = 6; -const OUT_280: usize = 1; -fn aiur_fn_280( - inp: [G; IN_280], +const INPUT_SIZE_282: usize = 6; +const IN_282: usize = 6; +const OUT_282: usize = 1; +fn aiur_fn_282( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_280], ExecError> { +) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + record.checkpoint(282); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<11>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -26662,26 +27389,26 @@ fn aiur_fn_280( 1u64 => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_280] = [__v_19]; - record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_282] = [__v_19]; + record.function_queries[282].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[282].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i)?; } record.function_queries[282].output_at(__i).to_array::() }, _ => aiur_fn_282(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_280] = [__v_23]; - record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_282] = [__v_23]; + record.function_queries[282].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -26693,104 +27420,106 @@ fn aiur_fn_280( }) } -const INPUT_SIZE_281: usize = 50; -const IN_281: usize = 50; -const OUT_281: usize = 12; -fn aiur_fn_281( - inp: [G; IN_281], +const INPUT_SIZE_283: usize = 50; +const IN_283: usize = 50; +const OUT_283: usize = 12; +fn aiur_fn_283( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_281], ExecError> { +) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; + record.checkpoint(283); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[274].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i)?; } record.function_queries[274].output_at(__i).to_array::() }, _ => aiur_fn_274(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[282].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i)?; } record.function_queries[282].output_at(__i).to_array::() }, _ => aiur_fn_282(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __ret: [G; OUT_281] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_283] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; + record.function_queries[283].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_282: usize = 1; -const IN_282: usize = 1; -const OUT_282: usize = 48; -fn aiur_fn_282( - inp: [G; IN_282], +const INPUT_SIZE_284: usize = 1; +const IN_284: usize = 1; +const OUT_284: usize = 48; +fn aiur_fn_284( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_282], ExecError> { +) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(284); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26828,10 +27557,10 @@ fn aiur_fn_282( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[21].bump_multiplicity(__i); } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[21].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[21].bump_multiplicity(__i)?; } record.function_queries[21].output_at(__i).to_array::() }, _ => aiur_fn_21(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -26881,7 +27610,7 @@ fn aiur_fn_282( let __v_84: G = __r_arr[46]; let __v_85: G = __r_arr[47]; let __v_86: G = __r_arr[48]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_87: G = __loaded[0]; let __v_88: G = __loaded[1]; let __v_89: G = __loaded[2]; @@ -26896,24 +27625,25 @@ fn aiur_fn_282( if (__v_89 != __v_91) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } - let __ret: [G; OUT_282] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_284] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + record.function_queries[284].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_283: usize = 1; -const IN_283: usize = 1; -const OUT_283: usize = 1; -fn aiur_fn_283( - inp: [G; IN_283], +const INPUT_SIZE_285: usize = 1; +const IN_285: usize = 1; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_283], ExecError> { +) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(285); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26951,16 +27681,16 @@ fn aiur_fn_283( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(3); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_38: G = __loaded[0]; let __v_39: G = __loaded[1]; let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_283] = [__v_39]; - record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_285] = [__v_39]; + record.function_queries[285].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26970,18 +27700,19 @@ fn aiur_fn_283( }) } -const INPUT_SIZE_284: usize = 1; -const IN_284: usize = 1; -const OUT_284: usize = 1; -fn aiur_fn_284( - inp: [G; IN_284], +const INPUT_SIZE_286: usize = 1; +const IN_286: usize = 1; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_284], ExecError> { +) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(286); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -27019,46 +27750,47 @@ fn aiur_fn_284( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(4); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[21].bump_multiplicity(__i); } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_284] = [__v_37]; - record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[21].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[21].bump_multiplicity(__i)?; } record.function_queries[21].output_at(__i).to_array::() }, _ => aiur_fn_21(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_286] = [__v_37]; + record.function_queries[286].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_285: usize = 2; -const IN_285: usize = 2; -const OUT_285: usize = 1; -fn aiur_fn_285( - inp: [G; IN_285], +const INPUT_SIZE_287: usize = 2; +const IN_287: usize = 2; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_285], ExecError> { +) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(287); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_285] = [__v_2]; - record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_287] = [__v_2]; + record.function_queries[287].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_285] = [__v_2]; - record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_287] = [__v_2]; + record.function_queries[287].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_285] = [__v_2]; - record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_287] = [__v_2]; + record.function_queries[287].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27067,14 +27799,14 @@ fn aiur_fn_285( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_285] = [__v_2]; - record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_287] = [__v_2]; + record.function_queries[287].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_285] = [__v_2]; - record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_287] = [__v_2]; + record.function_queries[287].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27086,48 +27818,49 @@ fn aiur_fn_285( }) } -const INPUT_SIZE_286: usize = 14; -const IN_286: usize = 14; -const OUT_286: usize = 1; -fn aiur_fn_286( - inp: [G; IN_286], +const INPUT_SIZE_288: usize = 14; +const IN_288: usize = 14; +const OUT_288: usize = 1; +fn aiur_fn_288( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_286], ExecError> { +) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(288); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[287].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i)?; } record.function_queries[287].output_at(__i).to_array::() }, _ => aiur_fn_287(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_17]; - record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_288] = [__v_17]; + record.function_queries[288].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[297].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i)?; } record.function_queries[297].output_at(__i).to_array::() }, _ => aiur_fn_297(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_286] = [__v_15]; - record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_288] = [__v_15]; + record.function_queries[288].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27136,18 +27869,19 @@ fn aiur_fn_286( }) } -const INPUT_SIZE_287: usize = 1; -const IN_287: usize = 1; -const OUT_287: usize = 1; -fn aiur_fn_287( - inp: [G; IN_287], +const INPUT_SIZE_289: usize = 1; +const IN_289: usize = 1; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_287], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(289); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -27200,25 +27934,25 @@ fn aiur_fn_287( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[285].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[285].output_at(__i).to_array::() }, _ => aiur_fn_285(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[287].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i)?; } record.function_queries[287].output_at(__i).to_array::() }, _ => aiur_fn_287(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_53]; }, _ => { let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_52, __v_53, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_51, __v_0, __v_54]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_55]; }, } @@ -27226,7 +27960,7 @@ fn aiur_fn_287( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[275].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i)?; } record.function_queries[275].output_at(__i).to_array::() }, _ => aiur_fn_275(__key, 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]; @@ -27239,16 +27973,16 @@ fn aiur_fn_287( let __v_60: G = __r_arr[9]; let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; - let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_63]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_289] = [__v_63]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[274].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[276].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i)?; } record.function_queries[276].output_at(__i).to_array::() }, _ => aiur_fn_276(__key, 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]; @@ -27261,16 +27995,16 @@ fn aiur_fn_287( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_64]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_289] = [__v_64]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[277].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i)?; } record.function_queries[277].output_at(__i).to_array::() }, _ => aiur_fn_277(__key, 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]; @@ -27283,18 +28017,18 @@ fn aiur_fn_287( let __v_61: G = __r_arr[9]; let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; - let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_64]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_289] = [__v_64]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[290].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i)?; } record.function_queries[290].output_at(__i).to_array::() }, _ => aiur_fn_290(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_49]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_289] = [__v_49]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27302,12 +28036,12 @@ fn aiur_fn_287( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[291].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i)?; } record.function_queries[291].output_at(__i).to_array::() }, _ => aiur_fn_291(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_50]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_289] = [__v_50]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27315,14 +28049,14 @@ fn aiur_fn_287( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_18, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_51]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_289] = [__v_51]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27330,12 +28064,12 @@ fn aiur_fn_287( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_10, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[293].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i)?; } record.function_queries[293].output_at(__i).to_array::() }, _ => aiur_fn_293(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_287] = [__v_50]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_289] = [__v_50]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27344,10 +28078,10 @@ fn aiur_fn_287( let __v_49: G = G::from_u64(0); let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[283].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[283].bump_multiplicity(__i)?; } record.function_queries[283].output_at(__i).to_array::() }, _ => aiur_fn_283(__key, 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]; @@ -27360,9 +28094,9 @@ fn aiur_fn_287( let __v_64: G = __r_arr[9]; let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; - let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_67]; - record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained); + let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_289] = [__v_67]; + record.function_queries[289].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27374,27 +28108,28 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 10; -const IN_288: usize = 10; -const OUT_288: usize = 1; -fn aiur_fn_288( - inp: [G; IN_288], +const INPUT_SIZE_290: usize = 10; +const IN_290: usize = 10; +const OUT_290: usize = 1; +fn aiur_fn_290( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_288], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(290); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -27447,7 +28182,7 @@ fn aiur_fn_288( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[774].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i)?; } record.function_queries[774].output_at(__i).to_array::() }, _ => aiur_fn_774(__key, 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]; @@ -27495,11 +28230,11 @@ fn aiur_fn_288( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[285].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[285].output_at(__i).to_array::() }, _ => aiur_fn_285(__key, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[288].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[288].bump_multiplicity(__i)?; } record.function_queries[288].output_at(__i).to_array::() }, _ => aiur_fn_288(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[275].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i)?; } record.function_queries[275].output_at(__i).to_array::() }, _ => aiur_fn_275(__key, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -27512,9 +28247,9 @@ fn aiur_fn_288( let __v_114: G = __r_arr[9]; let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; - let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_288] = [__v_117]; - record.function_queries[288].finish(&inp[..], &__ret[..], !unconstrained); + let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_290] = [__v_117]; + record.function_queries[290].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27531,19 +28266,20 @@ fn aiur_fn_288( }) } -const INPUT_SIZE_289: usize = 2; -const IN_289: usize = 2; -const OUT_289: usize = 1; -fn aiur_fn_289( - inp: [G; IN_289], +const INPUT_SIZE_291: usize = 2; +const IN_291: usize = 2; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(291); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -27596,7 +28332,7 @@ fn aiur_fn_289( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[294].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i)?; } record.function_queries[294].output_at(__i).to_array::() }, _ => aiur_fn_294(__key, 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]; @@ -27644,9 +28380,9 @@ fn aiur_fn_289( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[297].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i)?; } record.function_queries[297].output_at(__i).to_array::() }, _ => aiur_fn_297(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[280].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[280].bump_multiplicity(__i)?; } record.function_queries[280].output_at(__i).to_array::() }, _ => aiur_fn_280(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27659,9 +28395,9 @@ fn aiur_fn_289( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_289] = [__v_108]; - record.function_queries[289].finish(&inp[..], &__ret[..], !unconstrained); + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_291] = [__v_108]; + record.function_queries[291].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27678,20 +28414,21 @@ fn aiur_fn_289( }) } -const INPUT_SIZE_290: usize = 3; -const IN_290: usize = 3; -const OUT_290: usize = 1; -fn aiur_fn_290( - inp: [G; IN_290], +const INPUT_SIZE_292: usize = 3; +const IN_292: usize = 3; +const OUT_292: usize = 1; +fn aiur_fn_292( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(292); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -27744,7 +28481,7 @@ fn aiur_fn_290( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[294].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i)?; } record.function_queries[294].output_at(__i).to_array::() }, _ => aiur_fn_294(__key, 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]; @@ -27794,7 +28531,7 @@ fn aiur_fn_290( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_78, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_78, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[279].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[279].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[279].bump_multiplicity(__i)?; } record.function_queries[279].output_at(__i).to_array::() }, _ => aiur_fn_279(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27829,9 +28566,9 @@ fn aiur_fn_290( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[297].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i)?; } record.function_queries[297].output_at(__i).to_array::() }, _ => aiur_fn_297(__key, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[279].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[279].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[281].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i)?; } record.function_queries[281].output_at(__i).to_array::() }, _ => aiur_fn_281(__key, 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]; @@ -27844,9 +28581,9 @@ fn aiur_fn_290( let __v_140: G = __r_arr[9]; let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; - let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_290] = [__v_143]; - record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained); + let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_292] = [__v_143]; + record.function_queries[292].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -27865,19 +28602,20 @@ fn aiur_fn_290( }) } -const INPUT_SIZE_291: usize = 2; -const IN_291: usize = 2; -const OUT_291: usize = 1; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_293: usize = 2; +const IN_293: usize = 2; +const OUT_293: usize = 1; +fn aiur_fn_293( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_291], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(293); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -27930,7 +28668,7 @@ fn aiur_fn_291( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[294].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i)?; } record.function_queries[294].output_at(__i).to_array::() }, _ => aiur_fn_294(__key, 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]; @@ -27978,9 +28716,9 @@ fn aiur_fn_291( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[297].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i)?; } record.function_queries[297].output_at(__i).to_array::() }, _ => aiur_fn_297(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[283].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[283].bump_multiplicity(__i)?; } record.function_queries[283].output_at(__i).to_array::() }, _ => aiur_fn_283(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -27993,9 +28731,9 @@ fn aiur_fn_291( let __v_105: G = __r_arr[9]; let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; - let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_291] = [__v_108]; - record.function_queries[291].finish(&inp[..], &__ret[..], !unconstrained); + let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_293] = [__v_108]; + record.function_queries[293].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28012,19 +28750,20 @@ fn aiur_fn_291( }) } -const INPUT_SIZE_292: usize = 2; -const IN_292: usize = 2; -const OUT_292: usize = 45; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_294: usize = 2; +const IN_294: usize = 2; +const OUT_294: usize = 45; +fn aiur_fn_294( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(294); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -28076,14 +28815,14 @@ fn aiur_fn_292( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_292] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_294] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + record.function_queries[294].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_48, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[294].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i)?; } record.function_queries[294].output_at(__i).to_array::() }, _ => aiur_fn_294(__key, 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]; @@ -28129,8 +28868,8 @@ fn aiur_fn_292( let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; - let __ret: [G; OUT_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_294] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; + record.function_queries[294].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -28142,17 +28881,18 @@ fn aiur_fn_292( }) } -const INPUT_SIZE_293: usize = 1; -const IN_293: usize = 1; -const OUT_293: usize = 8; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_295: usize = 1; +const IN_295: usize = 1; +const OUT_295: usize = 8; +fn aiur_fn_295( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(295); + let __v_0: G = inp.values()[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); @@ -28162,35 +28902,36 @@ fn aiur_fn_293( let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + if !unconstrained { let __vi = __v_1; let __vj = __v_2; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_3; let __vj = __v_4; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_5; let __vj = __v_6; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_7; let __vj = __v_8; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } - let __ret: [G; OUT_293] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_295] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[295].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_294: usize = 3; -const IN_294: usize = 3; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_296: usize = 3; +const IN_296: usize = 3; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } }; + record.checkpoint(296); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[294].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i)?; } record.function_queries[294].output_at(__i).to_array::() }, _ => aiur_fn_294(__key, 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]; @@ -28236,7 +28977,7 @@ fn aiur_fn_294( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[295].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i)?; } record.function_queries[295].output_at(__i).to_array::() }, _ => aiur_fn_295(__key, 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]; @@ -28313,62 +29054,64 @@ fn aiur_fn_294( let __v_100: G = __mc_out___mc_0[44]; let __v_101: G = G::from_u64(1); let __v_102: G = G::from_u64(1); - let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_107: G = G::from_u64(1); let __v_108: G = G::from_u64(1); - let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_109: G = { let __values: [G; 3] = [__v_107, __v_108, __v_108]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_110: G = G::from_u64(1); let __v_111: G = G::from_u64(1); - let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_111]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_103, __v_106, __v_109, __v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[73].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i)?; } record.function_queries[73].output_at(__i).to_array::() }, _ => aiur_fn_73(__key, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_114]; - record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_296] = [__v_114]; + record.function_queries[296].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_295: usize = 2; -const IN_295: usize = 2; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_297: usize = 2; +const IN_297: usize = 2; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(297); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[298].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i)?; } record.function_queries[298].output_at(__i).to_array::() }, _ => aiur_fn_298(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_3]; - record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_297] = [__v_3]; + record.function_queries[297].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_296: usize = 4; -const IN_296: usize = 4; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_298: usize = 4; +const IN_298: usize = 4; +const OUT_298: usize = 1; +fn aiur_fn_298( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(298); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -28420,22 +29163,22 @@ fn aiur_fn_296( 1u64 => { let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_296] = [__v_53]; - record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained); + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_298] = [__v_53]; + record.function_queries[298].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[296].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i)?; } record.function_queries[296].output_at(__i).to_array::() }, _ => aiur_fn_296(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1, __v_50, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[298].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i)?; } record.function_queries[298].output_at(__i).to_array::() }, _ => aiur_fn_298(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_296] = [__v_56]; - record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained); + let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_298] = [__v_56]; + record.function_queries[298].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28445,75 +29188,76 @@ fn aiur_fn_296( }) } -const INPUT_SIZE_297: usize = 1; -const IN_297: usize = 1; -const OUT_297: usize = 1; -fn aiur_fn_297( - inp: [G; IN_297], +const INPUT_SIZE_299: usize = 1; +const IN_299: usize = 1; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_297], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(299); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_4]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_4]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_4]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_4]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_4]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_4]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[299].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i)?; } record.function_queries[299].output_at(__i).to_array::() }, _ => aiur_fn_299(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[299].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i)?; } record.function_queries[299].output_at(__i).to_array::() }, _ => aiur_fn_299(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_6]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_6]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_6]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_6]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_6]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_6]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[299].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i)?; } record.function_queries[299].output_at(__i).to_array::() }, _ => aiur_fn_299(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_4]; - record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_299] = [__v_4]; + record.function_queries[299].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28523,114 +29267,115 @@ fn aiur_fn_297( }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 1; -fn aiur_fn_298( - inp: [G; IN_298], +const INPUT_SIZE_300: usize = 2; +const IN_300: usize = 2; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_298], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(300); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_298] = [__v_10]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_10]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_298] = [__v_10]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_10]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -28638,14 +29383,14 @@ fn aiur_fn_298( 4u64 => { let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); - let __ret: [G; OUT_298] = [__v_9]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_9]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_8]; - record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_300] = [__v_8]; + record.function_queries[300].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -28657,39 +29402,40 @@ fn aiur_fn_298( }) } -const INPUT_SIZE_299: usize = 2; -const IN_299: usize = 2; -const OUT_299: usize = 1; -fn aiur_fn_299( - inp: [G; IN_299], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(301); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_299] = [__v_8]; - record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_301] = [__v_8]; + record.function_queries[301].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_299] = [__v_8]; - record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_301] = [__v_8]; + record.function_queries[301].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28698,40 +29444,40 @@ fn aiur_fn_299( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_299] = [__v_8]; - record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_301] = [__v_8]; + record.function_queries[301].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_299] = [__v_9]; - record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_301] = [__v_9]; + record.function_queries[301].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); - let __ret: [G; OUT_299] = [__v_10]; - record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_301] = [__v_10]; + record.function_queries[301].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[301].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i)?; } record.function_queries[301].output_at(__i).to_array::() }, _ => aiur_fn_301(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_10]; - record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_301] = [__v_10]; + record.function_queries[301].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28756,65 +29502,66 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 2; -const IN_300: usize = 2; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_302: usize = 2; +const IN_302: usize = 2; +const OUT_302: usize = 1; +fn aiur_fn_302( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_302], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(302); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_300] = [__v_5]; - record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_302] = [__v_5]; + record.function_queries[302].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_8]; - record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_302] = [__v_8]; + record.function_queries[302].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_300] = [__v_9]; - record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_302] = [__v_9]; + record.function_queries[302].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[302].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i)?; } record.function_queries[302].output_at(__i).to_array::() }, _ => aiur_fn_302(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_10]; - record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_302] = [__v_10]; + record.function_queries[302].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[302].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i)?; } record.function_queries[302].output_at(__i).to_array::() }, _ => aiur_fn_302(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_10]; - record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_302] = [__v_10]; + record.function_queries[302].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28839,39 +29586,40 @@ fn aiur_fn_300( }) } -const INPUT_SIZE_301: usize = 2; -const IN_301: usize = 2; -const OUT_301: usize = 1; -fn aiur_fn_301( - inp: [G; IN_301], +const INPUT_SIZE_303: usize = 2; +const IN_303: usize = 2; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(303); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_8]; - record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_303] = [__v_8]; + record.function_queries[303].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_8]; - record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_303] = [__v_8]; + record.function_queries[303].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28880,22 +29628,22 @@ fn aiur_fn_301( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_301] = [__v_8]; - record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_303] = [__v_8]; + record.function_queries[303].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[303].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i)?; } record.function_queries[303].output_at(__i).to_array::() }, _ => aiur_fn_303(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_301] = [__v_8]; - record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_303] = [__v_8]; + record.function_queries[303].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28910,19 +29658,20 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 2; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_304: usize = 2; +const IN_304: usize = 2; +const OUT_304: usize = 2; +fn aiur_fn_304( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(304); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -28932,40 +29681,40 @@ fn aiur_fn_302( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_5, __v_10]; - record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_304] = [__v_5, __v_10]; + record.function_queries[304].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_6, __v_8]; - record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_304] = [__v_6, __v_8]; + record.function_queries[304].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.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_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_302] = [__v_7, __v_1]; - record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_304] = [__v_7, __v_1]; + record.function_queries[304].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[304].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i)?; } record.function_queries[304].output_at(__i).to_array::() }, _ => aiur_fn_304(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_302] = [__v_7, __v_10]; - record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_304] = [__v_7, __v_10]; + record.function_queries[304].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -28985,77 +29734,78 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 3; -const IN_303: usize = 3; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_305: usize = 3; +const IN_305: usize = 3; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_303], ExecError> { +) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(305); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_11]; - record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_305] = [__v_11]; + record.function_queries[305].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_11]; - record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_305] = [__v_11]; + record.function_queries[305].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[305].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i)?; } record.function_queries[305].output_at(__i).to_array::() }, _ => aiur_fn_305(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_12]; - record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_305] = [__v_12]; + record.function_queries[305].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_10: G = { let __a_val = __v_7.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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_303] = [__v_13]; - record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_305] = [__v_13]; + record.function_queries[305].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_303] = [__v_0]; - record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_305] = [__v_0]; + record.function_queries[305].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29082,39 +29832,40 @@ fn aiur_fn_303( }) } -const INPUT_SIZE_304: usize = 2; -const IN_304: usize = 2; -const OUT_304: usize = 1; -fn aiur_fn_304( - inp: [G; IN_304], +const INPUT_SIZE_306: usize = 2; +const IN_306: usize = 2; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_304], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(306); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_304] = [__v_8]; - record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_306] = [__v_8]; + record.function_queries[306].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_8]; - record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_306] = [__v_8]; + record.function_queries[306].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29123,24 +29874,24 @@ fn aiur_fn_304( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_8]; - record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_306] = [__v_8]; + record.function_queries[306].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; match __v_8.as_canonical_u64() { _ => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; match __v_10.as_canonical_u64() { @@ -29151,24 +29902,24 @@ fn aiur_fn_304( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[306].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i)?; } record.function_queries[306].output_at(__i).to_array::() }, _ => aiur_fn_306(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_304] = [__v_14]; - record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_306] = [__v_14]; + record.function_queries[306].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_14]; - record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_306] = [__v_14]; + record.function_queries[306].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_304] = [__v_13]; - record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_306] = [__v_13]; + record.function_queries[306].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -29189,46 +29940,47 @@ fn aiur_fn_304( }) } -const INPUT_SIZE_305: usize = 1; -const IN_305: usize = 1; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_305], +const INPUT_SIZE_307: usize = 1; +const IN_307: usize = 1; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_305], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(307); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_4]; - record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_307] = [__v_4]; + record.function_queries[307].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[307].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i)?; } record.function_queries[307].output_at(__i).to_array::() }, _ => aiur_fn_307(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_305] = [__v_5]; - record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_307] = [__v_5]; + record.function_queries[307].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_305] = [__v_6]; - record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_307] = [__v_6]; + record.function_queries[307].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29245,88 +29997,89 @@ fn aiur_fn_305( }) } -const INPUT_SIZE_306: usize = 2; -const IN_306: usize = 2; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], +const INPUT_SIZE_308: usize = 2; +const IN_308: usize = 2; +const OUT_308: usize = 1; +fn aiur_fn_308( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_306], ExecError> { +) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(308); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_306] = [__v_0]; - record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_308] = [__v_0]; + record.function_queries[308].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_306] = [__v_0]; - record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_308] = [__v_0]; + record.function_queries[308].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; match __v_8.as_canonical_u64() { _ => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; match __v_10.as_canonical_u64() { _ => { - let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_12: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[308].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i)?; } record.function_queries[308].output_at(__i).to_array::() }, _ => aiur_fn_308(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_15]; - record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_308] = [__v_15]; + record.function_queries[308].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[308].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i)?; } record.function_queries[308].output_at(__i).to_array::() }, _ => aiur_fn_308(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_14]; - record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_308] = [__v_14]; + record.function_queries[308].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.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_14: G = { let __a_val = __v_11.as_canonical_u64(); let __b_val = __v_9.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[308].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i)?; } record.function_queries[308].output_at(__i).to_array::() }, _ => aiur_fn_308(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_306] = [__v_17]; - record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_308] = [__v_17]; + record.function_queries[308].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[308].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i)?; } record.function_queries[308].output_at(__i).to_array::() }, _ => aiur_fn_308(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_15]; - record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_308] = [__v_15]; + record.function_queries[308].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29360,41 +30113,42 @@ fn aiur_fn_306( }) } -const INPUT_SIZE_307: usize = 3; -const IN_307: usize = 3; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_309: usize = 3; +const IN_309: usize = 3; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(309); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_307] = [__v_0]; - record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_309] = [__v_0]; + record.function_queries[309].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[310].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i)?; } record.function_queries[310].output_at(__i).to_array::() }, _ => aiur_fn_310(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_6]; - record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_309] = [__v_6]; + record.function_queries[309].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_307] = [__v_0]; - record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_309] = [__v_0]; + record.function_queries[309].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29403,30 +30157,31 @@ fn aiur_fn_307( } }, _ => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[310].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i)?; } record.function_queries[310].output_at(__i).to_array::() }, _ => aiur_fn_310(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_307] = [__v_3]; - record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_309] = [__v_3]; + record.function_queries[309].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_308: usize = 3; -const IN_308: usize = 3; -const OUT_308: usize = 1; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_310: usize = 3; +const IN_310: usize = 3; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(310); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -29435,40 +30190,40 @@ fn aiur_fn_308( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_14]; - record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_310] = [__v_14]; + record.function_queries[310].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[301].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i)?; } record.function_queries[301].output_at(__i).to_array::() }, _ => aiur_fn_301(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_10: G = { let __a_val = __v_7.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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_13]; - record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_310] = [__v_13]; + record.function_queries[310].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_308] = [__v_0]; - record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_310] = [__v_0]; + record.function_queries[310].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29480,20 +30235,20 @@ fn aiur_fn_308( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_15]; - record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_310] = [__v_15]; + record.function_queries[310].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[310].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i)?; } record.function_queries[310].output_at(__i).to_array::() }, _ => aiur_fn_310(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_308] = [__v_12]; - record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_310] = [__v_12]; + record.function_queries[310].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -29507,21 +30262,22 @@ fn aiur_fn_308( }) } -const INPUT_SIZE_309: usize = 4; -const IN_309: usize = 4; -const OUT_309: usize = 1; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_311: usize = 4; +const IN_311: usize = 4; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], ExecError> { +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(311); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -29530,62 +30286,62 @@ fn aiur_fn_309( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_19]; - record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_7, __v_15, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_311] = [__v_19]; + record.function_queries[311].finish_prehashed(&inp, &__ret[..], !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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_1, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[301].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i)?; } record.function_queries[301].output_at(__i).to_array::() }, _ => aiur_fn_301(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_9, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[305].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i)?; } record.function_queries[305].output_at(__i).to_array::() }, _ => aiur_fn_305(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_14]; - record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_311] = [__v_14]; + record.function_queries[311].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_20]; - record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_311] = [__v_20]; + record.function_queries[311].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[311].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i)?; } record.function_queries[311].output_at(__i).to_array::() }, _ => aiur_fn_311(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_309] = [__v_13]; - record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_311] = [__v_13]; + record.function_queries[311].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -29599,83 +30355,84 @@ fn aiur_fn_309( }) } -const INPUT_SIZE_310: usize = 4; -const IN_310: usize = 4; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +const INPUT_SIZE_312: usize = 4; +const IN_312: usize = 4; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_310], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(312); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[309].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i)?; } record.function_queries[309].output_at(__i).to_array::() }, _ => aiur_fn_309(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_7]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_7]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_9]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_9]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_1, __v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_8]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_8]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[313].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i)?; } record.function_queries[313].output_at(__i).to_array::() }, _ => aiur_fn_313(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_7]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_7]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[304].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i)?; } record.function_queries[304].output_at(__i).to_array::() }, _ => aiur_fn_304(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[309].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i)?; } record.function_queries[309].output_at(__i).to_array::() }, _ => aiur_fn_309(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_9, __v_8, __v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[311].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i)?; } record.function_queries[311].output_at(__i).to_array::() }, _ => aiur_fn_311(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_10]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_10]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_310] = [__v_3]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_3]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3, __v_1, __v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[311].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i)?; } record.function_queries[311].output_at(__i).to_array::() }, _ => aiur_fn_311(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_9]; - record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_312] = [__v_9]; + record.function_queries[312].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -29692,76 +30449,77 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 5; -const IN_311: usize = 5; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_313: usize = 5; +const IN_313: usize = 5; +const OUT_313: usize = 1; +fn aiur_fn_313( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(313); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[309].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i)?; } record.function_queries[309].output_at(__i).to_array::() }, _ => aiur_fn_309(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_8]; - record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_313] = [__v_8]; + record.function_queries[313].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_6, __v_2, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_11]; - record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_313] = [__v_11]; + record.function_queries[313].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[313].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i)?; } record.function_queries[313].output_at(__i).to_array::() }, _ => aiur_fn_313(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[313].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i)?; } record.function_queries[313].output_at(__i).to_array::() }, _ => aiur_fn_313(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_9]; - record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_313] = [__v_9]; + record.function_queries[313].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[313].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i)?; } record.function_queries[313].output_at(__i).to_array::() }, _ => aiur_fn_313(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[313].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i)?; } record.function_queries[313].output_at(__i).to_array::() }, _ => aiur_fn_313(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_9]; - record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_313] = [__v_9]; + record.function_queries[313].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[304].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i)?; } record.function_queries[304].output_at(__i).to_array::() }, _ => aiur_fn_304(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[309].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i)?; } record.function_queries[309].output_at(__i).to_array::() }, _ => aiur_fn_309(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_10, __v_9, __v_6, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[311].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i)?; } record.function_queries[311].output_at(__i).to_array::() }, _ => aiur_fn_311(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_9, __v_3, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_12]; - record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_313] = [__v_12]; + record.function_queries[313].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -29770,17 +30528,17 @@ fn aiur_fn_311( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_2, __v_6, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[311].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i)?; } record.function_queries[311].output_at(__i).to_array::() }, _ => aiur_fn_311(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_2, __v_3, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_11]; - record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_313] = [__v_11]; + record.function_queries[313].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29795,37 +30553,38 @@ fn aiur_fn_311( }) } -const INPUT_SIZE_312: usize = 2; -const IN_312: usize = 2; -const OUT_312: usize = 1; -fn aiur_fn_312( - inp: [G; IN_312], +const INPUT_SIZE_314: usize = 2; +const IN_314: usize = 2; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_312], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(314); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_312] = [__v_0]; - record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_314] = [__v_0]; + record.function_queries[314].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[315].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i)?; } record.function_queries[315].output_at(__i).to_array::() }, _ => aiur_fn_315(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[314].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i)?; } record.function_queries[314].output_at(__i).to_array::() }, _ => aiur_fn_314(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_312] = [__v_8]; - record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_314] = [__v_8]; + record.function_queries[314].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -29835,53 +30594,54 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 2; -const IN_313: usize = 2; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_315: usize = 2; +const IN_315: usize = 2; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_313], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(315); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_313] = [__v_0]; - record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_315] = [__v_0]; + record.function_queries[315].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_8, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_8, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[302].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i)?; } record.function_queries[302].output_at(__i).to_array::() }, _ => aiur_fn_302(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[315].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i)?; } record.function_queries[315].output_at(__i).to_array::() }, _ => aiur_fn_315(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_12]; - record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_315] = [__v_12]; + record.function_queries[315].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[303].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i)?; } record.function_queries[303].output_at(__i).to_array::() }, _ => aiur_fn_303(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -29895,7 +30655,7 @@ fn aiur_fn_313( break '__mc_1 [__v_13]; }, 0u64 => { - let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; break '__mc_1 [__v_13]; }, _ => { @@ -29904,7 +30664,7 @@ fn aiur_fn_313( } }; let __v_13: G = __mc_out___mc_1[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -29914,11 +30674,11 @@ fn aiur_fn_313( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[307].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i)?; } record.function_queries[307].output_at(__i).to_array::() }, _ => aiur_fn_307(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); - let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; break '__mc_2 [__v_20]; }, _ => { @@ -29946,7 +30706,7 @@ fn aiur_fn_313( break '__mc_3 [__v_7]; }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -29955,7 +30715,7 @@ fn aiur_fn_313( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[308].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i)?; } record.function_queries[308].output_at(__i).to_array::() }, _ => aiur_fn_308(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -29970,11 +30730,11 @@ fn aiur_fn_313( } }; let __v_14: G = __mc_out___mc_3[0]; - let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_15: G = { let __values: [G; 3] = [__v_5, __v_13, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_15, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[315].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i)?; } record.function_queries[315].output_at(__i).to_array::() }, _ => aiur_fn_315(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_313] = [__v_16]; - record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_315] = [__v_16]; + record.function_queries[315].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -29990,29 +30750,30 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 1; -const IN_314: usize = 1; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_316: usize = 1; +const IN_316: usize = 1; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_314], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(316); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_314] = [__v_0]; - record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_316] = [__v_0]; + record.function_queries[316].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -30020,21 +30781,21 @@ fn aiur_fn_314( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[316].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i)?; } record.function_queries[316].output_at(__i).to_array::() }, _ => aiur_fn_316(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_10]; - record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_316] = [__v_10]; + record.function_queries[316].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_314] = [__v_0]; - record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_316] = [__v_0]; + record.function_queries[316].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30043,8 +30804,8 @@ fn aiur_fn_314( } }, _ => { - let __ret: [G; OUT_314] = [__v_0]; - record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_316] = [__v_0]; + record.function_queries[316].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -30058,43 +30819,44 @@ fn aiur_fn_314( }) } -const INPUT_SIZE_315: usize = 2; -const IN_315: usize = 2; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_317: usize = 2; +const IN_317: usize = 2; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } }; + record.checkpoint(317); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[316].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i)?; } record.function_queries[316].output_at(__i).to_array::() }, _ => aiur_fn_316(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[316].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i)?; } record.function_queries[316].output_at(__i).to_array::() }, _ => aiur_fn_316(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_315] = [__v_10]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_10]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_10]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_10]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30103,51 +30865,51 @@ fn aiur_fn_315( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_10]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_10]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_10, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[301].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i)?; } record.function_queries[301].output_at(__i).to_array::() }, _ => aiur_fn_301(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_12, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[306].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i)?; } record.function_queries[306].output_at(__i).to_array::() }, _ => aiur_fn_306(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[317].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i)?; } record.function_queries[317].output_at(__i).to_array::() }, _ => aiur_fn_317(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_315] = [__v_19]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_19]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_19]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_19]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30157,16 +30919,16 @@ fn aiur_fn_315( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_18]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_18]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_315] = [__v_17]; - record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_317] = [__v_17]; + record.function_queries[317].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -30187,56 +30949,57 @@ fn aiur_fn_315( }) } -const INPUT_SIZE_316: usize = 3; -const IN_316: usize = 3; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_318: usize = 3; +const IN_318: usize = 3; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(318); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_6]; - record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_318] = [__v_6]; + record.function_queries[318].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[302].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i)?; } record.function_queries[302].output_at(__i).to_array::() }, _ => aiur_fn_302(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[318].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i)?; } record.function_queries[318].output_at(__i).to_array::() }, _ => aiur_fn_318(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_10]; - record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_318] = [__v_10]; + record.function_queries[318].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[319].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i)?; } record.function_queries[319].output_at(__i).to_array::() }, _ => aiur_fn_319(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -30249,15 +31012,15 @@ fn aiur_fn_316( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_316] = [__v_12]; - record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_318] = [__v_12]; + record.function_queries[318].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[318].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i)?; } record.function_queries[318].output_at(__i).to_array::() }, _ => aiur_fn_318(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_12]; - record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_318] = [__v_12]; + record.function_queries[318].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30276,50 +31039,51 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 2; -const IN_317: usize = 2; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_319: usize = 2; +const IN_319: usize = 2; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_317], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(319); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_317] = [__v_5]; - record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_319] = [__v_5]; + record.function_queries[319].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; match __v_5.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); - let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_317] = [__v_10]; - record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_319] = [__v_10]; + record.function_queries[319].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[319].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i)?; } record.function_queries[319].output_at(__i).to_array::() }, _ => aiur_fn_319(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_10]; - record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_319] = [__v_10]; + record.function_queries[319].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30336,63 +31100,64 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 4; -const IN_318: usize = 4; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_320: usize = 4; +const IN_320: usize = 4; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(320); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_7]; - record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_320] = [__v_7]; + record.function_queries[320].finish_prehashed(&inp, &__ret[..], !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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[302].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i)?; } record.function_queries[302].output_at(__i).to_array::() }, _ => aiur_fn_302(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[320].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i)?; } record.function_queries[320].output_at(__i).to_array::() }, _ => aiur_fn_320(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_11]; - record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_320] = [__v_11]; + record.function_queries[320].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_9, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[321].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i)?; } record.function_queries[321].output_at(__i).to_array::() }, _ => aiur_fn_321(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_318] = [__v_12]; - record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_320] = [__v_12]; + record.function_queries[320].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[320].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i)?; } record.function_queries[320].output_at(__i).to_array::() }, _ => aiur_fn_320(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_12]; - record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_320] = [__v_12]; + record.function_queries[320].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30411,32 +31176,33 @@ fn aiur_fn_318( }) } -const INPUT_SIZE_319: usize = 3; -const IN_319: usize = 3; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_321: usize = 3; +const IN_321: usize = 3; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], ExecError> { +) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(321); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_6]; - record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_321] = [__v_6]; + record.function_queries[321].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { @@ -30444,19 +31210,19 @@ fn aiur_fn_319( let __v_8: G = (__v_6 - __v_1); match __v_8.as_canonical_u64() { 0u64 => { - let __v_9: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_7.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_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_319] = [__v_10]; - record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_321] = [__v_10]; + record.function_queries[321].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[321].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i)?; } record.function_queries[321].output_at(__i).to_array::() }, _ => aiur_fn_321(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_10]; - record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_321] = [__v_10]; + record.function_queries[321].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30465,10 +31231,10 @@ fn aiur_fn_319( } }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[321].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i)?; } record.function_queries[321].output_at(__i).to_array::() }, _ => aiur_fn_321(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_9]; - record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_321] = [__v_9]; + record.function_queries[321].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -30482,31 +31248,32 @@ fn aiur_fn_319( }) } -const INPUT_SIZE_320: usize = 2; -const IN_320: usize = 2; -const OUT_320: usize = 1; -fn aiur_fn_320( - inp: [G; IN_320], +const INPUT_SIZE_322: usize = 2; +const IN_322: usize = 2; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], ExecError> { +) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(322); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_320] = [__v_5]; - record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_322] = [__v_5]; + record.function_queries[322].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -30518,7 +31285,7 @@ fn aiur_fn_320( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[318].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i)?; } record.function_queries[318].output_at(__i).to_array::() }, _ => aiur_fn_318(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -30528,25 +31295,25 @@ fn aiur_fn_320( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_9]; - record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_322] = [__v_9]; + record.function_queries[322].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[323].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i)?; } record.function_queries[323].output_at(__i).to_array::() }, _ => aiur_fn_323(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_320] = [__v_10]; - record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_322] = [__v_10]; + record.function_queries[322].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[322].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i)?; } record.function_queries[322].output_at(__i).to_array::() }, _ => aiur_fn_322(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_10]; - record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_322] = [__v_10]; + record.function_queries[322].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30568,50 +31335,51 @@ fn aiur_fn_320( }) } -const INPUT_SIZE_321: usize = 3; -const IN_321: usize = 3; -const OUT_321: usize = 1; -fn aiur_fn_321( - inp: [G; IN_321], +const INPUT_SIZE_323: usize = 3; +const IN_323: usize = 3; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(323); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_321] = [__v_6]; - record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_323] = [__v_6]; + record.function_queries[323].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __loaded: [G; 2] = { let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 2 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<2>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_1, __v_2, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[320].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i)?; } record.function_queries[320].output_at(__i).to_array::() }, _ => aiur_fn_320(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_321] = [__v_9]; - record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_323] = [__v_9]; + record.function_queries[323].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[323].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i)?; } record.function_queries[323].output_at(__i).to_array::() }, _ => aiur_fn_323(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_321] = [__v_9]; - record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_323] = [__v_9]; + record.function_queries[323].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30628,86 +31396,88 @@ fn aiur_fn_321( }) } -const INPUT_SIZE_322: usize = 1; -const IN_322: usize = 1; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_324: usize = 1; +const IN_324: usize = 1; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(324); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_1, __v_9, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0, __v_16, __v_17, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[312].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i)?; } record.function_queries[312].output_at(__i).to_array::() }, _ => aiur_fn_312(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_18, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[314].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i)?; } record.function_queries[314].output_at(__i).to_array::() }, _ => aiur_fn_314(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_322] = [__v_19]; - record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_324] = [__v_19]; + record.function_queries[324].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_325: usize = 2; +const IN_325: usize = 2; +const OUT_325: usize = 1; +fn aiur_fn_325( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + record.checkpoint(325); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_3]; - record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_325] = [__v_3]; + record.function_queries[325].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_323] = [__v_6]; - record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_325] = [__v_6]; + record.function_queries[325].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[324].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i)?; } record.function_queries[324].output_at(__i).to_array::() }, _ => aiur_fn_324(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[324].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i)?; } record.function_queries[324].output_at(__i).to_array::() }, _ => aiur_fn_324(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[322].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i)?; } record.function_queries[322].output_at(__i).to_array::() }, _ => aiur_fn_322(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_323] = [__v_8]; - record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_325] = [__v_8]; + record.function_queries[325].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -30719,36 +31489,37 @@ fn aiur_fn_323( }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_326: usize = 2; +const IN_326: usize = 2; +const OUT_326: usize = 1; +fn aiur_fn_326( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + record.checkpoint(326); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_324] = [__v_3]; - record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_326] = [__v_3]; + record.function_queries[326].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[324].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i)?; } record.function_queries[324].output_at(__i).to_array::() }, _ => aiur_fn_324(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[324].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i)?; } record.function_queries[324].output_at(__i).to_array::() }, _ => aiur_fn_324(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[317].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i)?; } record.function_queries[317].output_at(__i).to_array::() }, _ => aiur_fn_317(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_324] = [__v_5]; - record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_326] = [__v_5]; + record.function_queries[326].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30758,38 +31529,39 @@ fn aiur_fn_324( }) } -const INPUT_SIZE_325: usize = 2; -const IN_325: usize = 2; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_327: usize = 2; +const IN_327: usize = 2; +const OUT_327: usize = 1; +fn aiur_fn_327( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_325], ExecError> { +) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; + record.checkpoint(327); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[332].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i)?; } record.function_queries[332].output_at(__i).to_array::() }, _ => aiur_fn_332(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[332].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i)?; } record.function_queries[332].output_at(__i).to_array::() }, _ => aiur_fn_332(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_325] = [__v_1]; - record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_327] = [__v_1]; + record.function_queries[327].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_325] = [__v_0]; - record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_327] = [__v_0]; + record.function_queries[327].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30798,90 +31570,91 @@ fn aiur_fn_325( } }, _ => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[328].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i)?; } record.function_queries[328].output_at(__i).to_array::() }, _ => aiur_fn_328(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_6]; - record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_327] = [__v_6]; + record.function_queries[327].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[328].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i)?; } record.function_queries[328].output_at(__i).to_array::() }, _ => aiur_fn_328(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_4]; - record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_327] = [__v_4]; + record.function_queries[327].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_326: usize = 2; -const IN_326: usize = 2; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_328: usize = 2; +const IN_328: usize = 2; +const OUT_328: usize = 1; +fn aiur_fn_328( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_326], ExecError> { +) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + record.checkpoint(328); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_0]; - record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_328] = [__v_0]; + record.function_queries[328].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_326] = [__v_1]; - record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_328] = [__v_1]; + record.function_queries[328].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_326] = [__v_0]; - record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_328] = [__v_0]; + record.function_queries[328].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[330].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i)?; } record.function_queries[330].output_at(__i).to_array::() }, _ => aiur_fn_330(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_1]; - record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_328] = [__v_1]; + record.function_queries[328].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[330].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i)?; } record.function_queries[330].output_at(__i).to_array::() }, _ => aiur_fn_330(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_326] = [__v_0]; - record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_328] = [__v_0]; + record.function_queries[328].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[331].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i)?; } record.function_queries[331].output_at(__i).to_array::() }, _ => aiur_fn_331(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_326] = [__v_11]; - record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_328] = [__v_11]; + record.function_queries[328].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -30905,123 +31678,124 @@ fn aiur_fn_326( }) } -const INPUT_SIZE_327: usize = 2; -const IN_327: usize = 2; -const OUT_327: usize = 1; -fn aiur_fn_327( - inp: [G; IN_327], +const INPUT_SIZE_329: usize = 2; +const IN_329: usize = 2; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], ExecError> { +) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(329); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_3]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_3]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_327] = [__v_11]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_11]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_327] = [__v_11]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_11]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -31031,22 +31805,22 @@ fn aiur_fn_327( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_10]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_10]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_10]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_10]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_327] = [__v_9]; - record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_329] = [__v_9]; + record.function_queries[329].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -31060,38 +31834,39 @@ fn aiur_fn_327( }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 1; -fn aiur_fn_328( - inp: [G; IN_328], +const INPUT_SIZE_330: usize = 2; +const IN_330: usize = 2; +const OUT_330: usize = 1; +fn aiur_fn_330( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], ExecError> { +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(330); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_328] = [__v_6]; - record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_330] = [__v_6]; + record.function_queries[330].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_328] = [__v_6]; - record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_330] = [__v_6]; + record.function_queries[330].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31101,48 +31876,49 @@ fn aiur_fn_328( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_328] = [__v_5]; - record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_330] = [__v_5]; + record.function_queries[330].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_329: usize = 2; -const IN_329: usize = 2; -const OUT_329: usize = 1; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_331: usize = 2; +const IN_331: usize = 2; +const OUT_331: usize = 1; +fn aiur_fn_331( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], ExecError> { +) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(331); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[333].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i)?; } record.function_queries[333].output_at(__i).to_array::() }, _ => aiur_fn_333(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[333].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i)?; } record.function_queries[333].output_at(__i).to_array::() }, _ => aiur_fn_333(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_329] = [__v_1]; - record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_331] = [__v_1]; + record.function_queries[331].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_329] = [__v_0]; - record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_331] = [__v_0]; + record.function_queries[331].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31152,9 +31928,9 @@ fn aiur_fn_329( }, 0u64 => { let __v_9: G = G::from_u64(2); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_329] = [__v_10]; - record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_331] = [__v_10]; + record.function_queries[331].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31164,18 +31940,19 @@ fn aiur_fn_329( }) } -const INPUT_SIZE_330: usize = 1; -const IN_330: usize = 1; -const OUT_330: usize = 2; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_332: usize = 1; +const IN_332: usize = 1; +const OUT_332: usize = 2; +fn aiur_fn_332( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(332); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -31183,12 +31960,12 @@ fn aiur_fn_330( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_330] = [__v_4, __v_5]; - record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_332] = [__v_4, __v_5]; + record.function_queries[332].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[332].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i)?; } record.function_queries[332].output_at(__i).to_array::() }, _ => aiur_fn_332(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -31196,15 +31973,15 @@ fn aiur_fn_330( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); - let __ret: [G; OUT_330] = [__v_6, __v_8]; - record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_332] = [__v_6, __v_8]; + record.function_queries[332].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_330] = [__v_6, __v_7]; - record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_332] = [__v_6, __v_7]; + record.function_queries[332].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -31212,27 +31989,28 @@ fn aiur_fn_330( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_330] = [__v_4, __v_5]; - record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_332] = [__v_4, __v_5]; + record.function_queries[332].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_331: usize = 2; -const IN_331: usize = 2; -const OUT_331: usize = 2; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_333: usize = 2; +const IN_333: usize = 2; +const OUT_333: usize = 2; +fn aiur_fn_333( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], ExecError> { +) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(333); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31240,35 +32018,36 @@ fn aiur_fn_331( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[333].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i)?; } record.function_queries[333].output_at(__i).to_array::() }, _ => aiur_fn_333(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_331] = [__v_7, __v_8]; - record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_333] = [__v_7, __v_8]; + record.function_queries[333].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_331] = [__v_0, __v_1]; - record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_333] = [__v_0, __v_1]; + record.function_queries[333].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_332: usize = 2; -const IN_332: usize = 2; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_334: usize = 2; +const IN_334: usize = 2; +const OUT_334: usize = 1; +fn aiur_fn_334( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], ExecError> { +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(334); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31276,54 +32055,54 @@ fn aiur_fn_332( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_7]; - record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_334] = [__v_7]; + record.function_queries[334].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[327].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i)?; } record.function_queries[327].output_at(__i).to_array::() }, _ => aiur_fn_327(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_5]; - record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_334] = [__v_5]; + record.function_queries[334].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[299].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i)?; } record.function_queries[299].output_at(__i).to_array::() }, _ => aiur_fn_299(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[327].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i)?; } record.function_queries[327].output_at(__i).to_array::() }, _ => aiur_fn_327(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_6]; - record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_334] = [__v_6]; + record.function_queries[334].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_332] = [__v_1]; - record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_334] = [__v_1]; + record.function_queries[334].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[300].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i)?; } record.function_queries[300].output_at(__i).to_array::() }, _ => aiur_fn_300(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_332] = [__v_0]; - record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_334] = [__v_0]; + record.function_queries[334].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_332] = [__v_11]; - record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_334] = [__v_11]; + record.function_queries[334].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31342,18 +32121,19 @@ fn aiur_fn_332( }) } -const INPUT_SIZE_333: usize = 1; -const IN_333: usize = 1; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_335: usize = 1; +const IN_335: usize = 1; +const OUT_335: usize = 1; +fn aiur_fn_335( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(335); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -31361,49 +32141,49 @@ fn aiur_fn_333( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_6]; - record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_335] = [__v_6]; + record.function_queries[335].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_6]; - record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_335] = [__v_6]; + record.function_queries[335].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_333] = [__v_7]; - record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_335] = [__v_7]; + record.function_queries[335].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[327].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i)?; } record.function_queries[327].output_at(__i).to_array::() }, _ => aiur_fn_327(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_6]; - record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_335] = [__v_6]; + record.function_queries[335].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[334].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i)?; } record.function_queries[334].output_at(__i).to_array::() }, _ => aiur_fn_334(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_6]; - record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_335] = [__v_6]; + record.function_queries[335].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31413,19 +32193,20 @@ fn aiur_fn_333( }) } -const INPUT_SIZE_334: usize = 2; -const IN_334: usize = 2; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_336: usize = 2; +const IN_336: usize = 2; +const OUT_336: usize = 1; +fn aiur_fn_336( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(336); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31433,48 +32214,48 @@ fn aiur_fn_334( 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_7]; - record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_336] = [__v_7]; + record.function_queries[336].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_334] = [__v_8]; - record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_336] = [__v_8]; + record.function_queries[336].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[327].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i)?; } record.function_queries[327].output_at(__i).to_array::() }, _ => aiur_fn_327(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_7]; - record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_336] = [__v_7]; + record.function_queries[336].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[334].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i)?; } record.function_queries[334].output_at(__i).to_array::() }, _ => aiur_fn_334(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_7]; - record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_336] = [__v_7]; + record.function_queries[336].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_5]; - record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_336] = [__v_5]; + record.function_queries[336].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31484,19 +32265,20 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 2; -const IN_335: usize = 2; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_337: usize = 2; +const IN_337: usize = 2; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(337); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31504,20 +32286,20 @@ fn aiur_fn_335( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_7]; - record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_337] = [__v_7]; + record.function_queries[337].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[337].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i)?; } record.function_queries[337].output_at(__i).to_array::() }, _ => aiur_fn_337(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_335] = [__v_8]; - record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_337] = [__v_8]; + record.function_queries[337].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31527,52 +32309,54 @@ fn aiur_fn_335( }) } -const INPUT_SIZE_336: usize = 2; -const IN_336: usize = 2; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_338: usize = 2; +const IN_338: usize = 2; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_338], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(338); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_336] = [__v_0]; - record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_338] = [__v_0]; + record.function_queries[338].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[339].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i)?; } record.function_queries[339].output_at(__i).to_array::() }, _ => aiur_fn_339(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_5]; - record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_338] = [__v_5]; + record.function_queries[338].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_337: usize = 2; -const IN_337: usize = 2; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_339: usize = 2; +const IN_339: usize = 2; +const OUT_339: usize = 1; +fn aiur_fn_339( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(339); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31581,95 +32365,95 @@ fn aiur_fn_337( 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_8]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_8]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[336].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i)?; } record.function_queries[336].output_at(__i).to_array::() }, _ => aiur_fn_336(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_9]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_9]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[337].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i)?; } record.function_queries[337].output_at(__i).to_array::() }, _ => aiur_fn_337(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_9]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_9]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_10]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_10]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_10]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_10]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_10]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_8]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_8]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_337] = [__v_8]; - record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_339] = [__v_8]; + record.function_queries[339].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31679,19 +32463,20 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 2; -const IN_338: usize = 2; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_340: usize = 2; +const IN_340: usize = 2; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(340); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -31704,7 +32489,7 @@ fn aiur_fn_338( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -31718,20 +32503,20 @@ fn aiur_fn_338( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_338] = [__v_22]; - record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_340] = [__v_22]; + record.function_queries[340].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_22]; - record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_340] = [__v_22]; + record.function_queries[340].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -31745,25 +32530,25 @@ fn aiur_fn_338( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_22]; - record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_340] = [__v_22]; + record.function_queries[340].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[340].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i)?; } record.function_queries[340].output_at(__i).to_array::() }, _ => aiur_fn_340(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_23]; - record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_340] = [__v_23]; + record.function_queries[340].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_338] = [__v_23]; - record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_340] = [__v_23]; + record.function_queries[340].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -31783,69 +32568,70 @@ fn aiur_fn_338( }) } -const INPUT_SIZE_339: usize = 2; -const IN_339: usize = 2; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_341: usize = 2; +const IN_341: usize = 2; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(341); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_339] = [__v_8]; - record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_341] = [__v_8]; + record.function_queries[341].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_8]; - record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_341] = [__v_8]; + record.function_queries[341].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_8]; - record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_341] = [__v_8]; + record.function_queries[341].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[341].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i)?; } record.function_queries[341].output_at(__i).to_array::() }, _ => aiur_fn_341(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_339] = [__v_9]; - record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_341] = [__v_9]; + record.function_queries[341].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_339] = [__v_9]; - record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_341] = [__v_9]; + record.function_queries[341].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -31862,34 +32648,35 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 4; -const IN_340: usize = 4; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_342: usize = 4; +const IN_342: usize = 4; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(342); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_0.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[340].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i)?; } record.function_queries[340].output_at(__i).to_array::() }, _ => aiur_fn_340(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_4]; - record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_342] = [__v_4]; + record.function_queries[342].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_4]; - record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_342] = [__v_4]; + record.function_queries[342].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -31897,16 +32684,16 @@ fn aiur_fn_340( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[341].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i)?; } record.function_queries[341].output_at(__i).to_array::() }, _ => aiur_fn_341(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_340] = [__v_4]; - record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_342] = [__v_4]; + record.function_queries[342].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_340] = [__v_4]; - record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_342] = [__v_4]; + record.function_queries[342].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -31918,18 +32705,19 @@ fn aiur_fn_340( }) } -const INPUT_SIZE_341: usize = 1; -const IN_341: usize = 1; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_343: usize = 1; +const IN_343: usize = 1; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(343); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -31938,77 +32726,77 @@ fn aiur_fn_341( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_341] = [__v_6]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_6]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_341] = [__v_5]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_5]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_341] = [__v_5]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_5]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_341] = [__v_5]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_5]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_7]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_7]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[346].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i)?; } record.function_queries[346].output_at(__i).to_array::() }, _ => aiur_fn_346(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_8]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_8]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[346].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i)?; } record.function_queries[346].output_at(__i).to_array::() }, _ => aiur_fn_346(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_8]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_8]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[342].bump_multiplicity(__i); } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[344].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i)?; } record.function_queries[344].output_at(__i).to_array::() }, _ => aiur_fn_344(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_5]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_5]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_5]; - record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_343] = [__v_5]; + record.function_queries[343].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32018,59 +32806,61 @@ fn aiur_fn_341( }) } -const INPUT_SIZE_342: usize = 3; -const IN_342: usize = 3; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_344: usize = 3; +const IN_344: usize = 3; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { +) -> Result<[G; OUT_344], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + record.checkpoint(344); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[346].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i)?; } record.function_queries[346].output_at(__i).to_array::() }, _ => aiur_fn_346(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_342] = [__v_8]; - record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_344] = [__v_8]; + record.function_queries[344].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_343: usize = 2; -const IN_343: usize = 2; -const OUT_343: usize = 1; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_345: usize = 2; +const IN_345: usize = 2; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], ExecError> { +) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(345); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_343] = [__v_1]; - record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_345] = [__v_1]; + record.function_queries[345].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_343] = [__v_0]; - record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_345] = [__v_0]; + record.function_queries[345].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32080,57 +32870,59 @@ fn aiur_fn_343( }) } -const INPUT_SIZE_344: usize = 1; -const IN_344: usize = 1; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_346: usize = 1; +const IN_346: usize = 1; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(346); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_344] = [__v_1]; - record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_346] = [__v_1]; + record.function_queries[346].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_344] = [__v_2]; - record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_346] = [__v_2]; + record.function_queries[346].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_345: usize = 2; -const IN_345: usize = 2; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], +const INPUT_SIZE_347: usize = 2; +const IN_347: usize = 2; +const OUT_347: usize = 1; +fn aiur_fn_347( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_345], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(347); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_345] = [__v_0]; - record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_347] = [__v_0]; + record.function_queries[347].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_345] = [__v_1]; - record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_347] = [__v_1]; + record.function_queries[347].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32140,38 +32932,39 @@ fn aiur_fn_345( }) } -const INPUT_SIZE_346: usize = 3; -const IN_346: usize = 3; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_348: usize = 3; +const IN_348: usize = 3; +const OUT_348: usize = 1; +fn aiur_fn_348( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], ExecError> { +) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(348); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_8]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_8]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_346] = [__v_8]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; + let __ret: [G; OUT_348] = [__v_8]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32181,37 +32974,37 @@ fn aiur_fn_346( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_346] = [__v_8]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_8]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_8]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_8]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32220,31 +33013,31 @@ fn aiur_fn_346( } }, 4u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i); } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[349].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[349].bump_multiplicity(__i)?; } record.function_queries[349].output_at(__i).to_array::() }, _ => aiur_fn_349(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i); } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[349].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[349].bump_multiplicity(__i)?; } record.function_queries[349].output_at(__i).to_array::() }, _ => aiur_fn_349(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[350].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i)?; } record.function_queries[350].output_at(__i).to_array::() }, _ => aiur_fn_350(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_346] = [__v_7]; - record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_348] = [__v_7]; + record.function_queries[348].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32254,27 +33047,28 @@ fn aiur_fn_346( }) } -const INPUT_SIZE_347: usize = 4; -const IN_347: usize = 4; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_349: usize = 4; +const IN_349: usize = 4; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + record.checkpoint(349); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_347] = [__v_5]; - record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_349] = [__v_5]; + record.function_queries[349].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -32282,10 +33076,10 @@ fn aiur_fn_347( let __v_6: G = (__v_2 + __v_5); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_1, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_9]; - record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_349] = [__v_9]; + record.function_queries[349].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32295,38 +33089,39 @@ fn aiur_fn_347( }) } -const INPUT_SIZE_348: usize = 5; -const IN_348: usize = 5; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_350: usize = 5; +const IN_350: usize = 5; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + record.checkpoint(350); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_348] = [__v_6]; - record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_350] = [__v_6]; + record.function_queries[350].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_348] = [__v_7]; - record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_350] = [__v_7]; + record.function_queries[350].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -32334,10 +33129,10 @@ fn aiur_fn_348( let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_2, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_348] = [__v_11]; - record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_350] = [__v_11]; + record.function_queries[350].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32352,60 +33147,62 @@ fn aiur_fn_348( }) } -const INPUT_SIZE_349: usize = 2; -const IN_349: usize = 2; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_351: usize = 2; +const IN_351: usize = 2; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(351); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[352].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i)?; } record.function_queries[352].output_at(__i).to_array::() }, _ => aiur_fn_352(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_349] = [__v_4]; - record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_351] = [__v_4]; + record.function_queries[351].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_350: usize = 2; -const IN_350: usize = 2; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_352: usize = 2; +const IN_352: usize = 2; +const OUT_352: usize = 1; +fn aiur_fn_352( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_352], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; + record.checkpoint(352); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[353].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i)?; } record.function_queries[353].output_at(__i).to_array::() }, _ => aiur_fn_353(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_350] = [__v_2]; - record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_352] = [__v_2]; + record.function_queries[352].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[352].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i)?; } record.function_queries[352].output_at(__i).to_array::() }, _ => aiur_fn_352(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_350] = [__v_7]; - record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_352] = [__v_7]; + record.function_queries[352].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32415,31 +33212,32 @@ fn aiur_fn_350( }) } -const INPUT_SIZE_351: usize = 1; -const IN_351: usize = 1; -const OUT_351: usize = 1; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_353: usize = 1; +const IN_353: usize = 1; +const OUT_353: usize = 1; +fn aiur_fn_353( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(353); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[354].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i)?; } record.function_queries[354].output_at(__i).to_array::() }, _ => aiur_fn_354(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_351] = [__v_7]; - record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_353] = [__v_7]; + record.function_queries[353].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32449,44 +33247,45 @@ fn aiur_fn_351( }) } -const INPUT_SIZE_352: usize = 2; -const IN_352: usize = 2; -const OUT_352: usize = 1; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_354: usize = 2; +const IN_354: usize = 2; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(354); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_352] = [__v_2]; - record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_354] = [__v_2]; + record.function_queries[354].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[353].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i)?; } record.function_queries[353].output_at(__i).to_array::() }, _ => aiur_fn_353(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_352] = [__v_2]; - record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_354] = [__v_2]; + record.function_queries[354].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[354].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i)?; } record.function_queries[354].output_at(__i).to_array::() }, _ => aiur_fn_354(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_352] = [__v_7]; - record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_354] = [__v_7]; + record.function_queries[354].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32498,48 +33297,49 @@ fn aiur_fn_352( }) } -const INPUT_SIZE_353: usize = 2; -const IN_353: usize = 2; -const OUT_353: usize = 1; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_355: usize = 2; +const IN_355: usize = 2; +const OUT_355: usize = 1; +fn aiur_fn_355( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], ExecError> { +) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(355); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_353] = [__v_4]; - record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_355] = [__v_4]; + record.function_queries[355].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_353] = [__v_0]; - record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_355] = [__v_0]; + record.function_queries[355].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[352].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i)?; } record.function_queries[352].output_at(__i).to_array::() }, _ => aiur_fn_352(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_355] = [__v_7]; + record.function_queries[355].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32551,74 +33351,76 @@ fn aiur_fn_353( }) } -const INPUT_SIZE_354: usize = 2; -const IN_354: usize = 2; -const OUT_354: usize = 1; -fn aiur_fn_354( - inp: [G; IN_354], +const INPUT_SIZE_356: usize = 2; +const IN_356: usize = 2; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], ExecError> { +) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + record.checkpoint(356); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, 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_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_354] = [__v_6]; - record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_356] = [__v_6]; + record.function_queries[356].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[357].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[357].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[357].bump_multiplicity(__i)?; } record.function_queries[357].output_at(__i).to_array::() }, _ => aiur_fn_357(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_6]; - record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_356] = [__v_6]; + record.function_queries[356].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_355: usize = 2; -const IN_355: usize = 2; -const OUT_355: usize = 1; -fn aiur_fn_355( - inp: [G; IN_355], +const INPUT_SIZE_357: usize = 2; +const IN_357: usize = 2; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], ExecError> { +) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(357); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_7]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_7]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); - let __ret: [G; OUT_355] = [__v_7]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_7]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32628,59 +33430,59 @@ fn aiur_fn_355( }, 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_8]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_8]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_3, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[358].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i)?; } record.function_queries[358].output_at(__i).to_array::() }, _ => aiur_fn_358(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_3, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[358].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i)?; } record.function_queries[358].output_at(__i).to_array::() }, _ => aiur_fn_358(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[357].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[357].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_4, __v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[359].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i)?; } record.function_queries[359].output_at(__i).to_array::() }, _ => aiur_fn_359(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_355] = [__v_6]; - record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_357] = [__v_6]; + record.function_queries[357].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32690,100 +33492,103 @@ fn aiur_fn_355( }) } -const INPUT_SIZE_356: usize = 3; -const IN_356: usize = 3; -const OUT_356: usize = 1; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_358: usize = 3; +const IN_358: usize = 3; +const OUT_358: usize = 1; +fn aiur_fn_358( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], ExecError> { +) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + record.checkpoint(358); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_356] = [__v_7]; - record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_358] = [__v_7]; + record.function_queries[358].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_357: usize = 4; -const IN_357: usize = 4; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_359: usize = 4; +const IN_359: usize = 4; +const OUT_359: usize = 1; +fn aiur_fn_359( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], ExecError> { +) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + record.checkpoint(359); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_2, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_357] = [__v_10]; - record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_359] = [__v_10]; + record.function_queries[359].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_358: usize = 3; -const IN_358: usize = 3; -const OUT_358: usize = 1; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_360: usize = 3; +const IN_360: usize = 3; +const OUT_360: usize = 1; +fn aiur_fn_360( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], ExecError> { +) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(360); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_358] = [__v_0]; - record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_360] = [__v_0]; + record.function_queries[360].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_358] = [__v_0]; - record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_360] = [__v_0]; + record.function_queries[360].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[361].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[361].bump_multiplicity(__i)?; } record.function_queries[361].output_at(__i).to_array::() }, _ => aiur_fn_361(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_358] = [__v_5]; - record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_360] = [__v_5]; + record.function_queries[360].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32795,110 +33600,111 @@ fn aiur_fn_358( }) } -const INPUT_SIZE_359: usize = 3; -const IN_359: usize = 3; -const OUT_359: usize = 1; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_361: usize = 3; +const IN_361: usize = 3; +const OUT_361: usize = 1; +fn aiur_fn_361( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], ExecError> { +) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(361); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[360].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i); } let __ret: [G; OUT_360] = unsafe { *(record.function_queries[360].output_at(__i).as_ptr() as *const [G; OUT_360]) }; __ret }, _ => aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[362].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i)?; } record.function_queries[362].output_at(__i).to_array::() }, _ => aiur_fn_362(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_359] = [__v_7]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_361] = [__v_7]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_9]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_9]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_11]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_11]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_5, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_13]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_13]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_5, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_13]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_13]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[363].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i)?; } record.function_queries[363].output_at(__i).to_array::() }, _ => aiur_fn_363(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_359] = [__v_7]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_361] = [__v_7]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_9]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_9]; - record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_361] = [__v_9]; + record.function_queries[361].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32908,36 +33714,37 @@ fn aiur_fn_359( }) } -const INPUT_SIZE_360: usize = 3; -const IN_360: usize = 3; -const OUT_360: usize = 1; -fn aiur_fn_360( - inp: [G; IN_360], +const INPUT_SIZE_362: usize = 3; +const IN_362: usize = 3; +const OUT_362: usize = 1; +fn aiur_fn_362( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_360], ExecError> { +) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(362); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_6]; - record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_362] = [__v_6]; + record.function_queries[362].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_360] = [__v_7]; - record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_362] = [__v_7]; + record.function_queries[362].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -32947,72 +33754,74 @@ fn aiur_fn_360( }) } -const INPUT_SIZE_361: usize = 5; -const IN_361: usize = 5; -const OUT_361: usize = 1; -fn aiur_fn_361( - inp: [G; IN_361], +const INPUT_SIZE_363: usize = 5; +const IN_363: usize = 5; +const OUT_363: usize = 1; +fn aiur_fn_363( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_361], ExecError> { +) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(363); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_2, __v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_11]; - record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_363] = [__v_11]; + record.function_queries[363].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_362: usize = 3; -const IN_362: usize = 3; -const OUT_362: usize = 1; -fn aiur_fn_362( - inp: [G; IN_362], +const INPUT_SIZE_364: usize = 3; +const IN_364: usize = 3; +const OUT_364: usize = 1; +fn aiur_fn_364( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_362], ExecError> { +) -> Result<[G; OUT_364], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(364); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_362] = [__v_0]; - record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_364] = [__v_0]; + record.function_queries[364].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_362] = [__v_0]; - record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_364] = [__v_0]; + record.function_queries[364].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[365].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[365].bump_multiplicity(__i)?; } record.function_queries[365].output_at(__i).to_array::() }, _ => aiur_fn_365(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_362] = [__v_5]; - record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_364] = [__v_5]; + record.function_queries[364].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33024,40 +33833,41 @@ fn aiur_fn_362( }) } -const INPUT_SIZE_363: usize = 3; -const IN_363: usize = 3; -const OUT_363: usize = 1; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_365: usize = 3; +const IN_365: usize = 3; +const OUT_365: usize = 1; +fn aiur_fn_365( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_363], ExecError> { +) -> Result<[G; OUT_365], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(365); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_363] = [__v_0]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_365] = [__v_0]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = (__v_4 - __v_1); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_11]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_11]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33068,89 +33878,89 @@ fn aiur_fn_363( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_9]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_9]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_11]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_11]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_13]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_13]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_13]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_13]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_13]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_13]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_9]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_9]; - record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_365] = [__v_9]; + record.function_queries[365].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33160,19 +33970,20 @@ fn aiur_fn_363( }) } -const INPUT_SIZE_364: usize = 2; -const IN_364: usize = 2; -const OUT_364: usize = 1; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_366: usize = 2; +const IN_366: usize = 2; +const OUT_366: usize = 1; +fn aiur_fn_366( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], ExecError> { +) -> Result<[G; OUT_366], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(366); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -33183,150 +33994,152 @@ fn aiur_fn_364( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_364] = [__v_7]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_7]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_364] = [__v_7]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_7]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_364] = [__v_7]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_7]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_7]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_7]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[365].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[367].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i)?; } record.function_queries[367].output_at(__i).to_array::() }, _ => aiur_fn_367(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_6]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[365].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[367].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i)?; } record.function_queries[367].output_at(__i).to_array::() }, _ => aiur_fn_367(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_6]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[366].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { *(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366]) }; __ret }, _ => aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_3, __v_4, __v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[368].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[368].bump_multiplicity(__i)?; } record.function_queries[368].output_at(__i).to_array::() }, _ => aiur_fn_368(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_6]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_6]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_6]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_364] = [__v_6]; - record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_366] = [__v_6]; + record.function_queries[366].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_365: usize = 3; -const IN_365: usize = 3; -const OUT_365: usize = 1; -fn aiur_fn_365( - inp: [G; IN_365], +const INPUT_SIZE_367: usize = 3; +const IN_367: usize = 3; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_365], ExecError> { +) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + record.checkpoint(367); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_365] = [__v_4]; - record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_367] = [__v_4]; + record.function_queries[367].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_365] = [__v_6]; - record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_367] = [__v_6]; + record.function_queries[367].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_366: usize = 4; -const IN_366: usize = 4; -const OUT_366: usize = 1; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_368: usize = 4; +const IN_368: usize = 4; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_366], ExecError> { +) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + record.checkpoint(368); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_366] = [__v_5]; - record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_368] = [__v_5]; + record.function_queries[368].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_366] = [__v_6]; - record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_368] = [__v_6]; + record.function_queries[368].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 + __v_6); - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_366] = [__v_8]; - record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_368] = [__v_8]; + record.function_queries[368].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -33335,48 +34148,49 @@ fn aiur_fn_366( }) } -const INPUT_SIZE_367: usize = 3; -const IN_367: usize = 3; -const OUT_367: usize = 1; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], ExecError> { +) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + record.checkpoint(369); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_367] = [__v_0]; - record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_369] = [__v_0]; + record.function_queries[369].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[366].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i)?; } record.function_queries[366].output_at(__i).to_array::() }, _ => aiur_fn_366(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[368].bump_multiplicity(__i); } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[370].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[370].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[370].bump_multiplicity(__i)?; } record.function_queries[370].output_at(__i).to_array::() }, _ => aiur_fn_370(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_367] = [__v_6]; - record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_369] = [__v_6]; + record.function_queries[369].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_367] = [__v_9]; - record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_369] = [__v_9]; + record.function_queries[369].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -33388,110 +34202,111 @@ fn aiur_fn_367( }) } -const INPUT_SIZE_368: usize = 3; -const IN_368: usize = 3; -const OUT_368: usize = 1; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_370: usize = 3; +const IN_370: usize = 3; +const OUT_370: usize = 1; +fn aiur_fn_370( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], ExecError> { +) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(370); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[371].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i)?; } record.function_queries[371].output_at(__i).to_array::() }, _ => aiur_fn_371(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_7]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_370] = [__v_7]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_9]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_9]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_11]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_11]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_13]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_13]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_13]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_13]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[370].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[370].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[370].bump_multiplicity(__i); } let __ret: [G; OUT_370] = unsafe { *(record.function_queries[370].output_at(__i).as_ptr() as *const [G; OUT_370]) }; __ret }, _ => aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[372].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i)?; } record.function_queries[372].output_at(__i).to_array::() }, _ => aiur_fn_372(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_368] = [__v_7]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_370] = [__v_7]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(7); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_9]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_368] = [__v_9]; - record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_370] = [__v_9]; + record.function_queries[370].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33501,28 +34316,29 @@ fn aiur_fn_368( }) } -const INPUT_SIZE_369: usize = 3; -const IN_369: usize = 3; -const OUT_369: usize = 1; -fn aiur_fn_369( - inp: [G; IN_369], +const INPUT_SIZE_371: usize = 3; +const IN_371: usize = 3; +const OUT_371: usize = 1; +fn aiur_fn_371( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], ExecError> { +) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + record.checkpoint(371); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_6]; - record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_371] = [__v_6]; + record.function_queries[371].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -33530,10 +34346,10 @@ fn aiur_fn_369( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_6]; - record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_371] = [__v_6]; + record.function_queries[371].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33541,9 +34357,9 @@ fn aiur_fn_369( let __v_6: G = G::from_u64(1); let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_369] = [__v_9]; - record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_371] = [__v_9]; + record.function_queries[371].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -33555,136 +34371,388 @@ fn aiur_fn_369( }) } -const INPUT_SIZE_370: usize = 5; -const IN_370: usize = 5; -const OUT_370: usize = 1; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_372: usize = 5; +const IN_372: usize = 5; +const OUT_372: usize = 1; +fn aiur_fn_372( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], ExecError> { +) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(372); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_2, __v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_370] = [__v_11]; - record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_372] = [__v_11]; + record.function_queries[372].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_371: usize = 3; -const IN_371: usize = 3; -const OUT_371: usize = 1; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_373: usize = 3; +const IN_373: usize = 3; +const OUT_373: usize = 1; +fn aiur_fn_373( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], ExecError> { +) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(373); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_371] = [__v_0]; - record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_373] = [__v_0]; + record.function_queries[373].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_1, __v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_373] = [__v_4]; + record.function_queries[373].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_374: usize = 3; +const IN_374: usize = 3; +const OUT_374: usize = 1; +fn aiur_fn_374( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_374], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(374); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_374] = [__v_5]; + record.function_queries[374].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_371] = [__v_0]; - record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = (__v_3 - __v_1); + let __ret: [G; OUT_374] = [__v_6]; + record.function_queries[374].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __v_6: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - match __v_7.as_canonical_u64() { + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[375].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i)?; } record.function_queries[375].output_at(__i).to_array::() }, _ => aiur_fn_375(__key, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_374] = [__v_6]; + record.function_queries[374].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_375: usize = 3; +const IN_375: usize = 3; +const OUT_375: usize = 1; +fn aiur_fn_375( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_375], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(375); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_375] = [__v_8]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[373].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => aiur_fn_373(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_8]; - record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 + __v_9); + let __v_11: G = (__v_4 - __v_10); + let __ret: [G; OUT_375] = [__v_11]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, - _ => { - let __v_8: G = (__v_2 + __v_3); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_9]; - record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained); + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_375] = [__v_9]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); }, } }, + 3u64 => { + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_375] = [__v_9]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_5, __v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_375] = [__v_13]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_5, __v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_375] = [__v_13]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[376].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i)?; } record.function_queries[376].output_at(__i).to_array::() }, _ => aiur_fn_376(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_375] = [__v_7]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_375] = [__v_7]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_375] = [__v_7]; + record.function_queries[375].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, } }) } -const INPUT_SIZE_372: usize = 3; -const IN_372: usize = 3; -const OUT_372: usize = 1; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_376: usize = 5; +const IN_376: usize = 5; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_372], ExecError> { +) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; - let __v_3: G = __r_arr[0]; - let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + record.checkpoint(376); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_3 + __v_8); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_4 + __v_10); + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_2, __v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_376] = [__v_13]; + record.function_queries[376].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }) +} + +const INPUT_SIZE_377: usize = 4; +const IN_377: usize = 4; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_377], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(377); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_377] = [__v_0]; + record.function_queries[377].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __v_6: G = (__v_3 + __v_2); + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[374].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i)?; } record.function_queries[374].output_at(__i).to_array::() }, _ => aiur_fn_374(__key, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = (__v_3 + __v_2); + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_377] = [__v_9]; + record.function_queries[377].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + let __v_8: G = (__v_2 - __v_7); + match __v_8.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[379].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[379].bump_multiplicity(__i)?; } record.function_queries[379].output_at(__i).to_array::() }, _ => aiur_fn_379(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_377] = [__v_9]; + record.function_queries[377].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_0, __v_9, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[379].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[379].bump_multiplicity(__i)?; } record.function_queries[379].output_at(__i).to_array::() }, _ => aiur_fn_379(__key, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_377] = [__v_10]; + record.function_queries[377].finish_prehashed(&inp, &__ret[..], !unconstrained)?; + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_378: usize = 4; +const IN_378: usize = 4; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: QueryKey, + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_378], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(378); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = (__v_0 - __v_3); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_6, __v_3, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_8]; - record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_378] = [__v_8]; + record.function_queries[378].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = (__v_0 - __v_3); + let __v_7: G = (__v_0 - __v_2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_372] = [__v_9]; - record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_378] = [__v_9]; + record.function_queries[378].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33694,189 +34762,194 @@ fn aiur_fn_372( }) } -const INPUT_SIZE_373: usize = 3; -const IN_373: usize = 3; -const OUT_373: usize = 1; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_379: usize = 4; +const IN_379: usize = 4; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], ExecError> { +) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_3: G = __loaded[0]; - let __v_4: G = __loaded[1]; - let __v_5: G = __loaded[2]; - let __v_6: G = __loaded[3]; - match __v_3.as_canonical_u64() { + record.checkpoint(379); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_7]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[378].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[378].bump_multiplicity(__i)?; } record.function_queries[378].output_at(__i).to_array::() }, _ => aiur_fn_378(__key, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_379] = [__v_8]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __v_7: G = G::from_u64(1); - let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_5, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_10]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __v_7: G = G::from_u64(2); - let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = G::from_u64(2); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_5, __v_6, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_10]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(3); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_11]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_12]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = G::from_u64(1); - let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_13]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = G::from_u64(4); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_3 + __v_10); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_1, __v_2, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_14]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = G::from_u64(1); - let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_13]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = G::from_u64(5); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_5, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_3 + __v_10); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_1, __v_2, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_14]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_7]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_5, __v_6, __v_7, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[380].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i)?; } record.function_queries[380].output_at(__i).to_array::() }, _ => aiur_fn_380(__key, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_379] = [__v_8]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __v_7: G = G::from_u64(7); - let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = G::from_u64(7); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_5, __v_6, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_10]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_9]; - record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = G::from_u64(8); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_5, __v_6, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_379] = [__v_10]; + record.function_queries[379].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); }, } }) } -const INPUT_SIZE_374: usize = 5; -const IN_374: usize = 5; -const OUT_374: usize = 1; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_380: usize = 6; +const IN_380: usize = 6; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], ExecError> { +) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + record.checkpoint(380); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = G::from_u64(6); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = G::from_u64(1); - let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; - let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_374] = [__v_11]; - record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_1, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_5 + __v_9); + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_2, __v_3, __v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[377].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i)?; } record.function_queries[377].output_at(__i).to_array::() }, _ => aiur_fn_377(__key, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_380] = [__v_12]; + record.function_queries[380].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_375: usize = 3; -const IN_375: usize = 3; -const OUT_375: usize = 3; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_381: usize = 3; +const IN_381: usize = 3; +const OUT_381: usize = 3; +fn aiur_fn_381( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_375], ExecError> { +) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(381); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_5, __v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[381].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i)?; } record.function_queries[381].output_at(__i).to_array::() }, _ => aiur_fn_381(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_375] = [__v_12, __v_13, __v_14]; - record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_381] = [__v_12, __v_13, __v_14]; + record.function_queries[381].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1]; - record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_381] = [__v_0, __v_2, __v_1]; + record.function_queries[381].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -33885,188 +34958,191 @@ fn aiur_fn_375( } }, _ => { - let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1]; - record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_381] = [__v_0, __v_2, __v_1]; + record.function_queries[381].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_376: usize = 3; -const IN_376: usize = 3; -const OUT_376: usize = 1; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_382: usize = 3; +const IN_382: usize = 3; +const OUT_382: usize = 1; +fn aiur_fn_382( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(382); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_1, __v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[381].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i)?; } record.function_queries[381].output_at(__i).to_array::() }, _ => aiur_fn_381(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_10]; - record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_382] = [__v_10]; + record.function_queries[382].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_13, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_14]; - record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_382] = [__v_14]; + record.function_queries[382].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_11, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_12]; - record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_382] = [__v_12]; + record.function_queries[382].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_377: usize = 3; -const IN_377: usize = 3; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_383: usize = 3; +const IN_383: usize = 3; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_383], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(383); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_7, __v_9, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_10]; - record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_383] = [__v_10]; + record.function_queries[383].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_1, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[382].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i)?; } record.function_queries[382].output_at(__i).to_array::() }, _ => aiur_fn_382(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_383] = [__v_7]; + record.function_queries[383].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i); } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[402].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i)?; } record.function_queries[402].output_at(__i).to_array::() }, _ => aiur_fn_402(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_383] = [__v_7]; + record.function_queries[383].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_9]; - record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_383] = [__v_9]; + record.function_queries[383].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[378].bump_multiplicity(__i); } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[384].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[384].bump_multiplicity(__i)?; } record.function_queries[384].output_at(__i).to_array::() }, _ => aiur_fn_384(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_383] = [__v_7]; + record.function_queries[383].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_7]; - record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_383] = [__v_7]; + record.function_queries[383].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_378: usize = 5; -const IN_378: usize = 5; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_384: usize = 5; +const IN_384: usize = 5; +const OUT_384: usize = 1; +fn aiur_fn_384( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], ExecError> { +) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(384); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[385].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[391].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i)?; } record.function_queries[391].output_at(__i).to_array::() }, _ => aiur_fn_391(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_10, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_11]; - record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_384] = [__v_11]; + record.function_queries[384].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[392].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i)?; } record.function_queries[392].output_at(__i).to_array::() }, _ => aiur_fn_392(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; @@ -34082,32 +35158,32 @@ fn aiur_fn_378( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_8, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_29, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_30]; - record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_384] = [__v_30]; + record.function_queries[384].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_29, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_30]; - record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_384] = [__v_30]; + record.function_queries[384].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_16, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_17]; - record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_384] = [__v_17]; + record.function_queries[384].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34116,16 +35192,17 @@ fn aiur_fn_378( }) } -const INPUT_SIZE_379: usize = 0; -const IN_379: usize = 0; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_385: usize = 0; +const IN_385: usize = 0; +const OUT_385: usize = 1; +fn aiur_fn_385( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_379], ExecError> { +) -> Result<[G; OUT_385], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(385); let __v_0: G = G::from_u64(167); let __v_1: G = G::from_u64(233); let __v_2: G = G::from_u64(168); @@ -34158,23 +35235,24 @@ fn aiur_fn_379( let __v_29: G = G::from_u64(201); let __v_30: G = G::from_u64(232); let __v_31: G = G::from_u64(96); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_379] = [__v_32]; - record.function_queries[379].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_385] = [__v_32]; + record.function_queries[385].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_380: usize = 0; -const IN_380: usize = 0; -const OUT_380: usize = 1; -fn aiur_fn_380( - inp: [G; IN_380], +const INPUT_SIZE_386: usize = 0; +const IN_386: usize = 0; +const OUT_386: usize = 1; +fn aiur_fn_386( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_380], ExecError> { +) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(386); let __v_0: G = G::from_u64(106); let __v_1: G = G::from_u64(247); let __v_2: G = G::from_u64(56); @@ -34207,23 +35285,24 @@ fn aiur_fn_380( let __v_29: G = G::from_u64(255); let __v_30: G = G::from_u64(167); let __v_31: G = G::from_u64(19); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_380] = [__v_32]; - record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_386] = [__v_32]; + record.function_queries[386].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_381: usize = 0; -const IN_381: usize = 0; -const OUT_381: usize = 1; -fn aiur_fn_381( - inp: [G; IN_381], +const INPUT_SIZE_387: usize = 0; +const IN_387: usize = 0; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_381], ExecError> { +) -> Result<[G; OUT_387], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(387); let __v_0: G = G::from_u64(29); let __v_1: G = G::from_u64(255); let __v_2: G = G::from_u64(253); @@ -34256,23 +35335,24 @@ fn aiur_fn_381( let __v_29: G = G::from_u64(39); let __v_30: G = G::from_u64(113); let __v_31: G = G::from_u64(77); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_381] = [__v_32]; - record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_387] = [__v_32]; + record.function_queries[387].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_382: usize = 0; -const IN_382: usize = 0; -const OUT_382: usize = 1; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_388: usize = 0; +const IN_388: usize = 0; +const OUT_388: usize = 1; +fn aiur_fn_388( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(388); let __v_0: G = G::from_u64(10); let __v_1: G = G::from_u64(76); let __v_2: G = G::from_u64(199); @@ -34305,23 +35385,24 @@ fn aiur_fn_382( let __v_29: G = G::from_u64(196); let __v_30: G = G::from_u64(89); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_382] = [__v_32]; - record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_388] = [__v_32]; + record.function_queries[388].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_383: usize = 0; -const IN_383: usize = 0; -const OUT_383: usize = 1; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_389: usize = 0; +const IN_389: usize = 0; +const OUT_389: usize = 1; +fn aiur_fn_389( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(389); let __v_0: G = G::from_u64(86); let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(118); @@ -34354,23 +35435,24 @@ fn aiur_fn_383( let __v_29: G = G::from_u64(78); let __v_30: G = G::from_u64(141); let __v_31: G = G::from_u64(48); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_32]; - record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_389] = [__v_32]; + record.function_queries[389].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_384: usize = 0; -const IN_384: usize = 0; -const OUT_384: usize = 1; -fn aiur_fn_384( - inp: [G; IN_384], +const INPUT_SIZE_390: usize = 0; +const IN_390: usize = 0; +const OUT_390: usize = 1; +fn aiur_fn_390( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_384], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(390); let __v_0: G = G::from_u64(2); let __v_1: G = G::from_u64(243); let __v_2: G = G::from_u64(88); @@ -34403,30 +35485,31 @@ fn aiur_fn_384( let __v_29: G = G::from_u64(45); let __v_30: G = G::from_u64(60); let __v_31: G = G::from_u64(93); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_32]; - record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_390] = [__v_32]; + record.function_queries[390].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_385: usize = 4; -const IN_385: usize = 4; -const OUT_385: usize = 2; -fn aiur_fn_385( - inp: [G; IN_385], +const INPUT_SIZE_391: usize = 4; +const IN_391: usize = 4; +const OUT_391: usize = 2; +fn aiur_fn_391( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_385], ExecError> { +) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; let __hit = record.function_queries[379].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => aiur_fn_379(__args, record, io_buffer, __cu)? } }; + record.checkpoint(391); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[385].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[385].bump_multiplicity(__i)?; } record.function_queries[385].output_at(__i).to_array::() }, _ => aiur_fn_385(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { @@ -34434,24 +35517,24 @@ fn aiur_fn_385( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_6, __v_10]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_6, __v_10]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[386].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i)?; } record.function_queries[386].output_at(__i).to_array::() }, _ => aiur_fn_386(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { @@ -34459,51 +35542,51 @@ fn aiur_fn_385( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_12, __v_16]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_12, __v_16]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); - let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_15, __v_19]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_15, __v_19]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; let __v_28: G = __loaded[3]; match __v_25.as_canonical_u64() { 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -34511,11 +35594,11 @@ fn aiur_fn_385( match __v_29.as_canonical_u64() { 4u64 => { let __v_33: G = G::from_u64(8); - let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_33, __v_0, __v_1, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_35: G = G::from_u64(4); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_37: G = { let __values: [G; 4] = [__v_35, __v_30, __v_34, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_38: G = __loaded[0]; let __v_39: G = __loaded[1]; let __v_40: G = __loaded[2]; @@ -34523,47 +35606,47 @@ fn aiur_fn_385( match __v_38.as_canonical_u64() { 4u64 => { let __v_42: G = G::from_u64(8); - let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_42, __v_0, __v_1, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(4); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[387].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i)?; } record.function_queries[387].output_at(__i).to_array::() }, _ => aiur_fn_387(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_47, __v_48, __v_51, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_54: G = G::from_u64(4); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_26, __v_53, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_57: G = G::from_u64(2); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_7, __v_8, __v_58]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_16, __v_61]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_63: G = G::from_u64(3); let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_56, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_66: G = G::from_u64(3); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_37, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_69: G = G::from_u64(3); let __v_70: G = G::from_u64(0); - let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_46, __v_70]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_72: G = G::from_u64(3); let __v_73: G = G::from_u64(0); - let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_74, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_74, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_77, __v_78]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_391] = [__v_77, __v_78]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -34571,9 +35654,9 @@ fn aiur_fn_385( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_42, __v_46]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 4] = [__v_43, __v_44, __v_45, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_42, __v_46]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34583,9 +35666,9 @@ fn aiur_fn_385( let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); - let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_33, __v_37]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_33, __v_37]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34595,9 +35678,9 @@ fn aiur_fn_385( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_29, __v_33]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_33: G = { let __values: [G; 4] = [__v_30, __v_31, __v_32, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_29, __v_33]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34611,9 +35694,9 @@ fn aiur_fn_385( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_10, __v_14]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_10, __v_14]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34623,9 +35706,9 @@ fn aiur_fn_385( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_385] = [__v_6, __v_10]; - record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_391] = [__v_6, __v_10]; + record.function_queries[391].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34634,28 +35717,29 @@ fn aiur_fn_385( }) } -const INPUT_SIZE_386: usize = 1; -const IN_386: usize = 1; -const OUT_386: usize = 1; -fn aiur_fn_386( - inp: [G; IN_386], +const INPUT_SIZE_392: usize = 1; +const IN_392: usize = 1; +const OUT_392: usize = 1; +fn aiur_fn_392( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_386], ExecError> { +) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(392); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_386] = [__v_5]; - record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_392] = [__v_5]; + record.function_queries[392].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -34664,33 +35748,34 @@ fn aiur_fn_386( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_386] = [__v_15]; - record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_392] = [__v_15]; + record.function_queries[392].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_387: usize = 2; -const IN_387: usize = 2; -const OUT_387: usize = 1; -fn aiur_fn_387( - inp: [G; IN_387], +const INPUT_SIZE_393: usize = 2; +const IN_393: usize = 2; +const OUT_393: usize = 1; +fn aiur_fn_393( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { +) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(393); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -34698,20 +35783,20 @@ fn aiur_fn_387( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_387] = [__v_7]; - record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_393] = [__v_7]; + record.function_queries[393].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_387] = [__v_8]; - record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_393] = [__v_8]; + record.function_queries[393].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -34721,67 +35806,68 @@ fn aiur_fn_387( }) } -const INPUT_SIZE_388: usize = 3; -const IN_388: usize = 3; -const OUT_388: usize = 2; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_394: usize = 3; +const IN_394: usize = 3; +const OUT_394: usize = 2; +fn aiur_fn_394( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_388], ExecError> { +) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + record.checkpoint(394); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __v_10: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_9.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_10: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_9.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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_11, __v_15]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_394] = [__v_11, __v_15]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_19, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_17, __v_20]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_394] = [__v_17, __v_20]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -34789,9 +35875,9 @@ fn aiur_fn_388( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_15, __v_19]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_394] = [__v_15, __v_19]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34802,41 +35888,41 @@ fn aiur_fn_388( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __v_10: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_9.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_10: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_9.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_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_11, __v_15]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_394] = [__v_11, __v_15]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[127].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i)?; } record.function_queries[127].output_at(__i).to_array::() }, _ => aiur_fn_127(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_20, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_17, __v_21]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_394] = [__v_17, __v_21]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -34844,9 +35930,9 @@ fn aiur_fn_388( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_388] = [__v_15, __v_19]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_394] = [__v_15, __v_19]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34854,11 +35940,11 @@ fn aiur_fn_388( } }, _ => { - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[266].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[266].bump_multiplicity(__i)?; } record.function_queries[266].output_at(__i).to_array::() }, _ => aiur_fn_266(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_388] = [__v_9, __v_10]; - record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_394] = [__v_9, __v_10]; + record.function_queries[394].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -34867,57 +35953,58 @@ fn aiur_fn_388( }) } -const INPUT_SIZE_389: usize = 2; -const IN_389: usize = 2; -const OUT_389: usize = 1; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_395: usize = 2; +const IN_395: usize = 2; +const OUT_395: usize = 1; +fn aiur_fn_395( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + record.checkpoint(395); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_389] = [__v_2]; - record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_395] = [__v_2]; + record.function_queries[395].finish_prehashed(&inp, &__ret[..], !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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_389] = [__v_2]; - record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_395] = [__v_2]; + record.function_queries[395].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_10, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_389] = [__v_17]; - record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_395] = [__v_17]; + record.function_queries[395].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -34932,20 +36019,21 @@ fn aiur_fn_389( }) } -const INPUT_SIZE_390: usize = 1; -const IN_390: usize = 1; -const OUT_390: usize = 1; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_396: usize = 1; +const IN_396: usize = 1; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], ExecError> { +) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + record.checkpoint(396); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { @@ -34953,9 +36041,9 @@ fn aiur_fn_390( break '__mc_0 [__v_3]; }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { @@ -34963,9 +36051,9 @@ fn aiur_fn_390( break '__mc_0 [__v_5]; }, _ => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { @@ -34973,9 +36061,9 @@ fn aiur_fn_390( break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { @@ -34983,9 +36071,9 @@ fn aiur_fn_390( break '__mc_0 [__v_9]; }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { @@ -34993,9 +36081,9 @@ fn aiur_fn_390( break '__mc_0 [__v_11]; }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { @@ -35003,9 +36091,9 @@ fn aiur_fn_390( break '__mc_0 [__v_13]; }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { @@ -35013,9 +36101,9 @@ fn aiur_fn_390( break '__mc_0 [__v_15]; }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { @@ -35023,9 +36111,9 @@ fn aiur_fn_390( break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { @@ -35033,9 +36121,9 @@ fn aiur_fn_390( break '__mc_0 [__v_19]; }, _ => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[176].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i)?; } record.function_queries[176].output_at(__i).to_array::() }, _ => aiur_fn_176(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 1u64 => { @@ -35043,9 +36131,9 @@ fn aiur_fn_390( break '__mc_0 [__v_21]; }, _ => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { @@ -35053,9 +36141,9 @@ fn aiur_fn_390( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { @@ -35063,9 +36151,9 @@ fn aiur_fn_390( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { @@ -35073,9 +36161,9 @@ fn aiur_fn_390( break '__mc_0 [__v_27]; }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[173].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i)?; } record.function_queries[173].output_at(__i).to_array::() }, _ => aiur_fn_173(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { @@ -35083,9 +36171,9 @@ fn aiur_fn_390( break '__mc_0 [__v_29]; }, _ => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { @@ -35093,9 +36181,9 @@ fn aiur_fn_390( break '__mc_0 [__v_31]; }, _ => { - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[175].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i)?; } record.function_queries[175].output_at(__i).to_array::() }, _ => aiur_fn_175(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { @@ -35142,64 +36230,64 @@ fn aiur_fn_390( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_390] = [__v_4]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_4]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_390] = [__v_5]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_5]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[199].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i)?; } record.function_queries[199].output_at(__i).to_array::() }, _ => aiur_fn_199(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); - let __ret: [G; OUT_390] = [__v_6]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_6]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); - let __ret: [G; OUT_390] = [__v_7]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_7]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[520].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[520].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[520].bump_multiplicity(__i)?; } record.function_queries[520].output_at(__i).to_array::() }, _ => aiur_fn_520(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_390] = [__v_8]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_8]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(6); - let __ret: [G; OUT_390] = [__v_9]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_9]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_390] = [__v_9]; - record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_396] = [__v_9]; + record.function_queries[396].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35216,71 +36304,72 @@ fn aiur_fn_390( }) } -const INPUT_SIZE_391: usize = 4; -const IN_391: usize = 4; -const OUT_391: usize = 2; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_397: usize = 4; +const IN_397: usize = 4; +const OUT_397: usize = 2; +fn aiur_fn_397( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } }; + record.checkpoint(397); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[396].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i)?; } record.function_queries[396].output_at(__i).to_array::() }, _ => aiur_fn_396(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[394].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[394].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[394].bump_multiplicity(__i)?; } record.function_queries[394].output_at(__i).to_array::() }, _ => aiur_fn_394(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_397] = [__v_5, __v_6]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[393].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i)?; } record.function_queries[393].output_at(__i).to_array::() }, _ => aiur_fn_393(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_6, __v_7]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_397] = [__v_6, __v_7]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[205].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i)?; } record.function_queries[205].output_at(__i).to_array::() }, _ => aiur_fn_205(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_397] = [__v_5, __v_6]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[189].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i)?; } record.function_queries[189].output_at(__i).to_array::() }, _ => aiur_fn_189(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_397] = [__v_5, __v_6]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[520].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[520].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { *(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520]) }; __ret }, _ => aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[526].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[526].bump_multiplicity(__i)?; } record.function_queries[526].output_at(__i).to_array::() }, _ => aiur_fn_526(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_397] = [__v_5, __v_6]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_391] = [__v_5, __v_6]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_397] = [__v_5, __v_6]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -35288,53 +36377,54 @@ fn aiur_fn_391( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_391] = [__v_5, __v_9]; - record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_397] = [__v_5, __v_9]; + record.function_queries[397].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_392: usize = 3; -const IN_392: usize = 3; -const OUT_392: usize = 2; -fn aiur_fn_392( - inp: [G; IN_392], +const INPUT_SIZE_398: usize = 3; +const IN_398: usize = 3; +const OUT_398: usize = 2; +fn aiur_fn_398( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_392], ExecError> { +) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } }; + record.checkpoint(398); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[389].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[389].bump_multiplicity(__i)?; } record.function_queries[389].output_at(__i).to_array::() }, _ => aiur_fn_389(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[393].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i); } let __ret: [G; OUT_393] = unsafe { *(record.function_queries[393].output_at(__i).as_ptr() as *const [G; OUT_393]) }; __ret }, _ => aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[399].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[399].bump_multiplicity(__i)?; } record.function_queries[399].output_at(__i).to_array::() }, _ => aiur_fn_399(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_5, __v_6]; - record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_398] = [__v_5, __v_6]; + record.function_queries[398].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[390].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i)?; } record.function_queries[390].output_at(__i).to_array::() }, _ => aiur_fn_390(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[394].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[394].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[394].bump_multiplicity(__i); } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[400].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i)?; } record.function_queries[400].output_at(__i).to_array::() }, _ => aiur_fn_400(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_392] = [__v_7, __v_8]; - record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_398] = [__v_7, __v_8]; + record.function_queries[398].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -35342,9 +36432,9 @@ fn aiur_fn_392( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_392] = [__v_7, __v_11]; - record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_398] = [__v_7, __v_11]; + record.function_queries[398].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35353,56 +36443,57 @@ fn aiur_fn_392( }) } -const INPUT_SIZE_393: usize = 2; -const IN_393: usize = 2; -const OUT_393: usize = 2; -fn aiur_fn_393( - inp: [G; IN_393], +const INPUT_SIZE_399: usize = 2; +const IN_399: usize = 2; +const OUT_399: usize = 2; +fn aiur_fn_399( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_393], ExecError> { +) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(399); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); - let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_393] = [__v_5, __v_9]; - record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_399] = [__v_5, __v_9]; + record.function_queries[399].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[401].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[401].bump_multiplicity(__i)?; } record.function_queries[401].output_at(__i).to_array::() }, _ => aiur_fn_401(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_16, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_13, __v_17]; - record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_399] = [__v_13, __v_17]; + record.function_queries[399].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -35410,9 +36501,9 @@ fn aiur_fn_393( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_393] = [__v_11, __v_15]; - record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_399] = [__v_11, __v_15]; + record.function_queries[399].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35421,56 +36512,57 @@ fn aiur_fn_393( }) } -const INPUT_SIZE_394: usize = 2; -const IN_394: usize = 2; -const OUT_394: usize = 2; -fn aiur_fn_394( - inp: [G; IN_394], +const INPUT_SIZE_400: usize = 2; +const IN_400: usize = 2; +const OUT_400: usize = 2; +fn aiur_fn_400( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_394], ExecError> { +) -> Result<[G; OUT_400], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(400); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); - let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_5, __v_9]; - record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_400] = [__v_5, __v_9]; + record.function_queries[400].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[401].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[401].bump_multiplicity(__i)?; } record.function_queries[401].output_at(__i).to_array::() }, _ => aiur_fn_401(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_16, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_394] = [__v_13, __v_17]; - record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_400] = [__v_13, __v_17]; + record.function_queries[400].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -35478,9 +36570,9 @@ fn aiur_fn_394( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_394] = [__v_11, __v_15]; - record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_400] = [__v_11, __v_15]; + record.function_queries[400].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35489,37 +36581,38 @@ fn aiur_fn_394( }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; -const OUT_395: usize = 2; -fn aiur_fn_395( - inp: [G; IN_395], +const INPUT_SIZE_401: usize = 2; +const IN_401: usize = 2; +const OUT_401: usize = 2; +fn aiur_fn_401( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_395], ExecError> { +) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(401); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[388].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[388].bump_multiplicity(__i)?; } record.function_queries[388].output_at(__i).to_array::() }, _ => aiur_fn_388(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -35527,10 +36620,10 @@ fn aiur_fn_395( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_14, __v_16]; - record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_401] = [__v_14, __v_16]; + record.function_queries[401].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -35538,9 +36631,9 @@ fn aiur_fn_395( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_14, __v_18]; - record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_401] = [__v_14, __v_18]; + record.function_queries[401].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35550,9 +36643,9 @@ fn aiur_fn_395( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_11, __v_15]; - record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_401] = [__v_11, __v_15]; + record.function_queries[401].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35562,50 +36655,51 @@ fn aiur_fn_395( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_395] = [__v_9, __v_13]; - record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_401] = [__v_9, __v_13]; + record.function_queries[401].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_396: usize = 5; -const IN_396: usize = 5; -const OUT_396: usize = 1; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_402: usize = 5; +const IN_402: usize = 5; +const OUT_402: usize = 1; +fn aiur_fn_402( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], ExecError> { +) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } }; + record.checkpoint(402); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[397].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i)?; } record.function_queries[397].output_at(__i).to_array::() }, _ => aiur_fn_397(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_7]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_7]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_396] = [__v_6]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_6]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -35620,52 +36714,52 @@ fn aiur_fn_396( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_11, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[403].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i)?; } record.function_queries[403].output_at(__i).to_array::() }, _ => aiur_fn_403(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_21, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_22]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_22, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_23]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_23]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_20]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_20]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[398].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i)?; } record.function_queries[398].output_at(__i).to_array::() }, _ => aiur_fn_398(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_21, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_22]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_22]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_22]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35676,10 +36770,10 @@ fn aiur_fn_396( let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[414].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i)?; } record.function_queries[414].output_at(__i).to_array::() }, _ => aiur_fn_414(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[406].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i)?; } record.function_queries[406].output_at(__i).to_array::() }, _ => aiur_fn_406(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; @@ -35694,46 +36788,46 @@ fn aiur_fn_396( let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_396] = [__v_24]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_24]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[410].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i)?; } record.function_queries[410].output_at(__i).to_array::() }, _ => aiur_fn_410(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_27, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_28]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_28]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_396] = [__v_27]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_27]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[413].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i)?; } record.function_queries[413].output_at(__i).to_array::() }, _ => aiur_fn_413(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_29, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_30]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_30]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_396] = [__v_27]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_27]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35741,10 +36835,10 @@ fn aiur_fn_396( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_28]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_28]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35752,10 +36846,10 @@ fn aiur_fn_396( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_20]; - record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_402] = [__v_20]; + record.function_queries[402].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35764,20 +36858,21 @@ fn aiur_fn_396( }) } -const INPUT_SIZE_397: usize = 2; -const IN_397: usize = 2; -const OUT_397: usize = 2; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_403: usize = 2; +const IN_403: usize = 2; +const OUT_403: usize = 2; +fn aiur_fn_403( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], ExecError> { +) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(403); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[398].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[404].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i)?; } record.function_queries[404].output_at(__i).to_array::() }, _ => aiur_fn_404(__key, 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]; @@ -35785,32 +36880,32 @@ fn aiur_fn_397( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_10, __v_14]; - record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_403] = [__v_10, __v_14]; + record.function_queries[403].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); - let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_14, __v_15]; - record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_403] = [__v_14, __v_15]; + record.function_queries[403].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35820,28 +36915,29 @@ fn aiur_fn_397( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_397] = [__v_8, __v_12]; - record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_403] = [__v_8, __v_12]; + record.function_queries[403].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_398: usize = 2; -const IN_398: usize = 2; -const OUT_398: usize = 5; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_404: usize = 2; +const IN_404: usize = 2; +const OUT_404: usize = 5; +fn aiur_fn_404( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_398], ExecError> { +) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(404); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -35850,33 +36946,33 @@ fn aiur_fn_398( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[398].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[404].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i)?; } record.function_queries[404].output_at(__i).to_array::() }, _ => aiur_fn_404(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; let __v_11: G = __r_arr[3]; let __v_12: G = __r_arr[4]; - let __ret: [G; OUT_398] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_404] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + record.function_queries[404].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 0u64 => { - let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_1 - __v_12); let __v_14: G = (__v_13 - __v_7); - let __ret: [G; OUT_398] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_404] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + record.function_queries[404].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -35914,11 +37010,11 @@ fn aiur_fn_398( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_404] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + record.function_queries[404].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -35958,11 +37054,11 @@ fn aiur_fn_398( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_404] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + record.function_queries[404].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36002,29 +37098,30 @@ fn aiur_fn_398( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_398] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_404] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + record.function_queries[404].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_399: usize = 1; -const IN_399: usize = 1; -const OUT_399: usize = 1; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_405: usize = 1; +const IN_405: usize = 1; +const OUT_405: usize = 1; +fn aiur_fn_405( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], ExecError> { +) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(405); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -36033,84 +37130,85 @@ fn aiur_fn_399( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[149].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i)?; } record.function_queries[149].output_at(__i).to_array::() }, _ => aiur_fn_149(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_399] = [__v_12]; - record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_405] = [__v_12]; + record.function_queries[405].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[127].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i)?; } record.function_queries[127].output_at(__i).to_array::() }, _ => aiur_fn_127(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(7); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_12, __v_13, __v_16, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_399] = [__v_21]; - record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_405] = [__v_21]; + record.function_queries[405].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_399] = [__v_0]; - record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_405] = [__v_0]; + record.function_queries[405].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_399] = [__v_0]; - record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_405] = [__v_0]; + record.function_queries[405].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_400: usize = 9; -const IN_400: usize = 9; -const OUT_400: usize = 2; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_406: usize = 9; +const IN_406: usize = 9; +const OUT_406: usize = 2; +fn aiur_fn_406( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(406); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -36123,9 +37221,9 @@ fn aiur_fn_400( let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -36133,15 +37231,15 @@ fn aiur_fn_400( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_19, __v_23]; - record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_406] = [__v_19, __v_23]; + record.function_queries[406].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[407].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i)?; } record.function_queries[407].output_at(__i).to_array::() }, _ => aiur_fn_407(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { @@ -36149,31 +37247,31 @@ fn aiur_fn_400( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); - let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_21, __v_25]; - record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained); + let __v_25: G = { let __values: [G; 4] = [__v_22, __v_23, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_406] = [__v_21, __v_25]; + record.function_queries[406].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_21, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_28, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_29, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_400] = [__v_30, __v_31]; - record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_406] = [__v_30, __v_31]; + record.function_queries[406].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36187,57 +37285,58 @@ fn aiur_fn_400( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_400] = [__v_14, __v_18]; - record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_406] = [__v_14, __v_18]; + record.function_queries[406].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_401: usize = 5; -const IN_401: usize = 5; -const OUT_401: usize = 1; -fn aiur_fn_401( - inp: [G; IN_401], +const INPUT_SIZE_407: usize = 5; +const IN_407: usize = 5; +const OUT_407: usize = 1; +fn aiur_fn_407( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_401], ExecError> { +) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + record.checkpoint(407); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_401] = [__v_14]; - record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_407] = [__v_14]; + record.function_queries[407].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -36252,27 +37351,27 @@ fn aiur_fn_401( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_22, __v_23, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[560].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i)?; } record.function_queries[560].output_at(__i).to_array::() }, _ => aiur_fn_560(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_32, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_6, __v_33, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_34]; - record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_407] = [__v_34]; + record.function_queries[407].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_401] = [__v_27]; - record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_407] = [__v_27]; + record.function_queries[407].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36281,75 +37380,77 @@ fn aiur_fn_401( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_401] = [__v_13]; - record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_407] = [__v_13]; + record.function_queries[407].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_402: usize = 3; -const IN_402: usize = 3; -const OUT_402: usize = 1; -fn aiur_fn_402( - inp: [G; IN_402], +const INPUT_SIZE_408: usize = 3; +const IN_408: usize = 3; +const OUT_408: usize = 1; +fn aiur_fn_408( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_402], ExecError> { +) -> Result<[G; OUT_408], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + record.checkpoint(408); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 + __v_4); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_3, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_12, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_13]; - record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_408] = [__v_13]; + record.function_queries[408].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_403: usize = 2; -const IN_403: usize = 2; -const OUT_403: usize = 1; -fn aiur_fn_403( - inp: [G; IN_403], +const INPUT_SIZE_409: usize = 2; +const IN_409: usize = 2; +const OUT_409: usize = 1; +fn aiur_fn_409( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_403], ExecError> { +) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(409); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -36364,103 +37465,104 @@ fn aiur_fn_403( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_22, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_23, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[409].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i)?; } record.function_queries[409].output_at(__i).to_array::() }, _ => aiur_fn_409(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_24]; - record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_409] = [__v_24]; + record.function_queries[409].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_403] = [__v_2]; - record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_409] = [__v_2]; + record.function_queries[409].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_403] = [__v_2]; - record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_409] = [__v_2]; + record.function_queries[409].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_404: usize = 10; -const IN_404: usize = 10; -const OUT_404: usize = 2; -fn aiur_fn_404( - inp: [G; IN_404], +const INPUT_SIZE_410: usize = 10; +const IN_410: usize = 10; +const OUT_410: usize = 2; +fn aiur_fn_410( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_404], ExecError> { +) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(410); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; let __v_10: G = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_14.as_canonical_u64() { 0u64 => { 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 = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_404] = [__v_15, __v_19]; - record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_410] = [__v_15, __v_19]; + record.function_queries[410].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[262].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[262].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[264].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i)?; } record.function_queries[264].output_at(__i).to_array::() }, _ => aiur_fn_264(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_404] = [__v_17, __v_16]; - record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_410] = [__v_17, __v_16]; + record.function_queries[410].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[261].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i)?; } record.function_queries[261].output_at(__i).to_array::() }, _ => aiur_fn_261(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_18, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[409].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i)?; } record.function_queries[409].output_at(__i).to_array::() }, _ => aiur_fn_409(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[261].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i)?; } record.function_queries[261].output_at(__i).to_array::() }, _ => aiur_fn_261(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[399].bump_multiplicity(__i); } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[405].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[405].bump_multiplicity(__i)?; } record.function_queries[405].output_at(__i).to_array::() }, _ => aiur_fn_405(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[405].bump_multiplicity(__i); } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[411].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[411].bump_multiplicity(__i)?; } record.function_queries[411].output_at(__i).to_array::() }, _ => aiur_fn_411(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i); } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_6, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[412].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i)?; } record.function_queries[412].output_at(__i).to_array::() }, _ => aiur_fn_412(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_24, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { @@ -36468,40 +37570,40 @@ fn aiur_fn_404( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_12, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[408].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i)?; } record.function_queries[408].output_at(__i).to_array::() }, _ => aiur_fn_408(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_32, __v_33]; - record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_410] = [__v_32, __v_33]; + record.function_queries[410].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_28, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_28, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_25, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_12 + __v_38); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_31, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_31, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_41, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_42, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_42, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_404] = [__v_44, __v_43]; - record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_410] = [__v_44, __v_43]; + record.function_queries[410].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -36510,13 +37612,13 @@ fn aiur_fn_404( } }, _ => { - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_12, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[408].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i)?; } record.function_queries[408].output_at(__i).to_array::() }, _ => aiur_fn_408(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_8, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_27, __v_28]; - record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_410] = [__v_27, __v_28]; + record.function_queries[410].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36527,30 +37629,31 @@ fn aiur_fn_404( }) } -const INPUT_SIZE_405: usize = 1; -const IN_405: usize = 1; -const OUT_405: usize = 4; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_411: usize = 1; +const IN_411: usize = 1; +const OUT_411: usize = 4; +fn aiur_fn_411( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(411); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -36566,10 +37669,10 @@ fn aiur_fn_405( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[469].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i)?; } record.function_queries[469].output_at(__i).to_array::() }, _ => aiur_fn_469(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_20, __v_13, __v_21, __v_2]; - record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_411] = [__v_20, __v_13, __v_21, __v_2]; + record.function_queries[411].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -36607,12 +37710,12 @@ fn aiur_fn_405( let __v_51: G = G::from_u64(0); let __v_52: G = G::from_u64(0); let __v_53: G = G::from_u64(0); - let __v_54: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); - let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_20, __v_21, __v_54, __v_57]; - record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained); + let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_411] = [__v_20, __v_21, __v_54, __v_57]; + record.function_queries[411].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36652,31 +37755,32 @@ fn aiur_fn_405( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 32] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_405] = [__v_7, __v_8, __v_41, __v_44]; - record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained); + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_411] = [__v_7, __v_8, __v_41, __v_44]; + record.function_queries[411].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_406: usize = 2; -const IN_406: usize = 2; -const OUT_406: usize = 3; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_412: usize = 2; +const IN_412: usize = 2; +const OUT_412: usize = 3; +fn aiur_fn_412( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], ExecError> { +) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(412); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -36689,9 +37793,9 @@ fn aiur_fn_406( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_406] = [__v_7, __v_8, __v_12]; - record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_412] = [__v_7, __v_8, __v_12]; + record.function_queries[412].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -36701,17 +37805,17 @@ fn aiur_fn_406( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_406] = [__v_8, __v_4, __v_5]; - record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_412] = [__v_8, __v_4, __v_5]; + record.function_queries[412].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i); } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[412].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i)?; } record.function_queries[412].output_at(__i).to_array::() }, _ => aiur_fn_412(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_406] = [__v_8, __v_9, __v_10]; - record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_412] = [__v_8, __v_9, __v_10]; + record.function_queries[412].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36725,26 +37829,27 @@ fn aiur_fn_406( }) } -const INPUT_SIZE_407: usize = 9; -const IN_407: usize = 9; -const OUT_407: usize = 2; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_413: usize = 9; +const IN_413: usize = 9; +const OUT_413: usize = 2; +fn aiur_fn_413( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], ExecError> { +) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(413); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -36756,13 +37861,13 @@ fn aiur_fn_407( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_14, __v_18]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_14, __v_18]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -36774,9 +37879,9 @@ fn aiur_fn_407( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_19, __v_23]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_19, __v_23]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -36785,7 +37890,7 @@ fn aiur_fn_407( let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[414].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i)?; } record.function_queries[414].output_at(__i).to_array::() }, _ => aiur_fn_414(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -36794,15 +37899,15 @@ fn aiur_fn_407( let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_24, __v_28]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_24, __v_28]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -36823,7 +37928,7 @@ fn aiur_fn_407( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[416].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i)?; } record.function_queries[416].output_at(__i).to_array::() }, _ => aiur_fn_416(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -36831,19 +37936,19 @@ fn aiur_fn_407( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); - let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_40, __v_44]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_40, __v_44]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { @@ -36851,15 +37956,15 @@ fn aiur_fn_407( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_44, __v_48]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_44, __v_48]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_40, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_40, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_44, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_44, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[475].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i)?; } record.function_queries[475].output_at(__i).to_array::() }, _ => aiur_fn_475(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { @@ -36867,32 +37972,32 @@ fn aiur_fn_407( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_46, __v_50]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_46, __v_50]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_12, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = (__v_3 + __v_4); let __v_48: G = (__v_47 + __v_5); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_46, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[415].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i)?; } record.function_queries[415].output_at(__i).to_array::() }, _ => aiur_fn_415(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_21 + __v_53); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_52, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_52, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_407] = [__v_56, __v_57]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_413] = [__v_56, __v_57]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36906,9 +38011,9 @@ fn aiur_fn_407( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_39, __v_43]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_39, __v_43]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36918,9 +38023,9 @@ fn aiur_fn_407( let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_39, __v_43]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_39, __v_43]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36930,9 +38035,9 @@ fn aiur_fn_407( let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_407] = [__v_37, __v_41]; - record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained); + let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_413] = [__v_37, __v_41]; + record.function_queries[413].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -36953,31 +38058,32 @@ fn aiur_fn_407( }) } -const INPUT_SIZE_408: usize = 2; -const IN_408: usize = 2; -const OUT_408: usize = 2; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_414: usize = 2; +const IN_414: usize = 2; +const OUT_414: usize = 2; +fn aiur_fn_414( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], ExecError> { +) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(414); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -36985,8 +38091,8 @@ fn aiur_fn_408( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_408] = [__v_12, __v_9]; - record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_414] = [__v_12, __v_9]; + record.function_queries[414].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -37023,9 +38129,9 @@ fn aiur_fn_408( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_12, __v_45]; - record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained); + let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_414] = [__v_12, __v_45]; + record.function_queries[414].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37064,15 +38170,15 @@ fn aiur_fn_408( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_6, __v_39]; - record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained); + let __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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_414] = [__v_6, __v_39]; + record.function_queries[414].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37081,11 +38187,11 @@ fn aiur_fn_408( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[414].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i)?; } record.function_queries[414].output_at(__i).to_array::() }, _ => aiur_fn_414(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_408] = [__v_8, __v_9]; - record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_414] = [__v_8, __v_9]; + record.function_queries[414].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -37122,9 +38228,9 @@ fn aiur_fn_408( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_6, __v_39]; - record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained); + let __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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_414] = [__v_6, __v_39]; + record.function_queries[414].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37133,60 +38239,62 @@ fn aiur_fn_408( }) } -const INPUT_SIZE_409: usize = 5; -const IN_409: usize = 5; -const OUT_409: usize = 1; -fn aiur_fn_409( - inp: [G; IN_409], +const INPUT_SIZE_415: usize = 5; +const IN_415: usize = 5; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_409], ExecError> { +) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(415); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_409] = [__v_0]; - record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(8); - let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_4 + __v_11); - let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[415].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i)?; } record.function_queries[415].output_at(__i).to_array::() }, _ => aiur_fn_415(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_13]; - record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_415] = [__v_13]; + record.function_queries[415].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_410: usize = 1; -const IN_410: usize = 1; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_416: usize = 1; +const IN_416: usize = 1; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_410], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(416); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37201,38 +38309,39 @@ fn aiur_fn_410( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[411].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[411].bump_multiplicity(__i); } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[417].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i)?; } record.function_queries[417].output_at(__i).to_array::() }, _ => aiur_fn_417(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[418].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[418].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[418].bump_multiplicity(__i)?; } record.function_queries[418].output_at(__i).to_array::() }, _ => aiur_fn_418(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_410] = [__v_16]; - record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_416] = [__v_16]; + record.function_queries[416].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_410] = [__v_14]; - record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_416] = [__v_14]; + record.function_queries[416].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_411: usize = 2; -const IN_411: usize = 2; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_417: usize = 2; +const IN_417: usize = 2; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_411], ExecError> { +) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(417); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -37285,20 +38394,20 @@ fn aiur_fn_411( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[297].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i)?; } record.function_queries[297].output_at(__i).to_array::() }, _ => aiur_fn_297(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_50]; - record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_417] = [__v_50]; + record.function_queries[417].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(1); let __v_52: G = G::from_u64(1); - let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_411] = [__v_54]; - record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained); + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_417] = [__v_54]; + record.function_queries[417].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37307,34 +38416,35 @@ fn aiur_fn_411( }) } -const INPUT_SIZE_412: usize = 6; -const IN_412: usize = 6; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_418: usize = 6; +const IN_418: usize = 6; +const OUT_418: usize = 1; +fn aiur_fn_418( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_412], ExecError> { +) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(418); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = (__v_2 - __v_5); match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_412] = [__v_7]; - record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_418] = [__v_7]; + record.function_queries[418].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -37349,32 +38459,32 @@ fn aiur_fn_412( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_10, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[419].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i)?; } record.function_queries[419].output_at(__i).to_array::() }, _ => aiur_fn_419(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_20, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[420].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i)?; } record.function_queries[420].output_at(__i).to_array::() }, _ => aiur_fn_420(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_22]; - record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_418] = [__v_22]; + record.function_queries[418].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[418].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[418].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[418].bump_multiplicity(__i)?; } record.function_queries[418].output_at(__i).to_array::() }, _ => aiur_fn_418(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_24]; - record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_418] = [__v_24]; + record.function_queries[418].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_412] = [__v_20]; - record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_418] = [__v_20]; + record.function_queries[418].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37383,26 +38493,27 @@ fn aiur_fn_412( }) } -const INPUT_SIZE_413: usize = 2; -const IN_413: usize = 2; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_419: usize = 2; +const IN_419: usize = 2; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_413], ExecError> { +) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(419); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_413] = [__v_0]; - record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_419] = [__v_0]; + record.function_queries[419].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -37411,15 +38522,15 @@ fn aiur_fn_413( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[419].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i)?; } record.function_queries[419].output_at(__i).to_array::() }, _ => aiur_fn_419(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_8]; - record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_419] = [__v_8]; + record.function_queries[419].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_413] = [__v_0]; - record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_419] = [__v_0]; + record.function_queries[419].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37428,160 +38539,162 @@ fn aiur_fn_413( }) } -const INPUT_SIZE_414: usize = 2; -const IN_414: usize = 2; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_420: usize = 2; +const IN_420: usize = 2; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], ExecError> { +) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(420); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_414] = [__v_7]; - record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_420] = [__v_7]; + record.function_queries[420].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[420].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i)?; } record.function_queries[420].output_at(__i).to_array::() }, _ => aiur_fn_420(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_7]; - record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_420] = [__v_7]; + record.function_queries[420].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_414] = [__v_6]; - record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_420] = [__v_6]; + record.function_queries[420].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_415: usize = 2; -const IN_415: usize = 2; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +const INPUT_SIZE_421: usize = 2; +const IN_421: usize = 2; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_415], ExecError> { +) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(421); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[422].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i)?; } record.function_queries[422].output_at(__i).to_array::() }, _ => aiur_fn_422(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_6]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_6]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_7]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_7]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_415] = [__v_8]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_8]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_8]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_8]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37589,60 +38702,61 @@ fn aiur_fn_415( } }, 8u64 => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[421].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i)?; } record.function_queries[421].output_at(__i).to_array::() }, _ => aiur_fn_421(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_6]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_6]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_415] = [__v_6]; - record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_421] = [__v_6]; + record.function_queries[421].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_416: usize = 2; -const IN_416: usize = 2; -const OUT_416: usize = 1; -fn aiur_fn_416( - inp: [G; IN_416], +const INPUT_SIZE_422: usize = 2; +const IN_422: usize = 2; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], ExecError> { +) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(422); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_416] = [__v_5]; - record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_422] = [__v_5]; + record.function_queries[422].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_416] = [__v_6]; - record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_422] = [__v_6]; + record.function_queries[422].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[422].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i)?; } record.function_queries[422].output_at(__i).to_array::() }, _ => aiur_fn_422(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_6]; - record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_422] = [__v_6]; + record.function_queries[422].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -37654,291 +38768,296 @@ fn aiur_fn_416( }) } -const INPUT_SIZE_417: usize = 2; -const IN_417: usize = 2; -const OUT_417: usize = 1; -fn aiur_fn_417( - inp: [G; IN_417], +const INPUT_SIZE_423: usize = 2; +const IN_423: usize = 2; +const OUT_423: usize = 1; +fn aiur_fn_423( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], ExecError> { +) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(423); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_417] = [__v_0]; - record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_423] = [__v_0]; + record.function_queries[423].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_417] = [__v_0]; - record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_423] = [__v_0]; + record.function_queries[423].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_417] = [__v_0]; - record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_423] = [__v_0]; + record.function_queries[423].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_417] = [__v_0]; - record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_423] = [__v_0]; + record.function_queries[423].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_417] = [__v_0]; - record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_423] = [__v_0]; + record.function_queries[423].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_10, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_11]; - record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_423] = [__v_11]; + record.function_queries[423].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_418: usize = 2; -const IN_418: usize = 2; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_424: usize = 2; +const IN_424: usize = 2; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], ExecError> { +) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(424); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[383].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i)?; } record.function_queries[383].output_at(__i).to_array::() }, _ => aiur_fn_383(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_5]; - record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_424] = [__v_5]; + record.function_queries[424].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_419: usize = 2; -const IN_419: usize = 2; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_425: usize = 2; +const IN_425: usize = 2; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], ExecError> { +) -> Result<[G; OUT_425], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(425); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_419] = [__v_0]; - record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_425] = [__v_0]; + record.function_queries[425].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_419] = [__v_0]; - record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_425] = [__v_0]; + record.function_queries[425].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_419] = [__v_0]; - record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_425] = [__v_0]; + record.function_queries[425].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_419] = [__v_0]; - record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_425] = [__v_0]; + record.function_queries[425].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_419] = [__v_0]; - record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_425] = [__v_0]; + record.function_queries[425].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[426].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i)?; } record.function_queries[426].output_at(__i).to_array::() }, _ => aiur_fn_426(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_11]; - record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_425] = [__v_11]; + record.function_queries[425].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_420: usize = 3; -const IN_420: usize = 3; -const OUT_420: usize = 1; -fn aiur_fn_420( - inp: [G; IN_420], +const INPUT_SIZE_426: usize = 3; +const IN_426: usize = 3; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_420], ExecError> { +) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(426); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_7, __v_9, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[426].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i)?; } record.function_queries[426].output_at(__i).to_array::() }, _ => aiur_fn_426(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_10]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_10]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_0, __v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[381].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i)?; } record.function_queries[381].output_at(__i).to_array::() }, _ => aiur_fn_381(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_14]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_14]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_11, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_10, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_17, __v_12, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[426].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i)?; } record.function_queries[426].output_at(__i).to_array::() }, _ => aiur_fn_426(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_18]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_18]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_11, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_15, __v_12, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[426].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i)?; } record.function_queries[426].output_at(__i).to_array::() }, _ => aiur_fn_426(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_16]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_16]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[426].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i)?; } record.function_queries[426].output_at(__i).to_array::() }, _ => aiur_fn_426(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_9]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_9]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[421].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i); } let __ret: [G; OUT_421] = unsafe { *(record.function_queries[421].output_at(__i).as_ptr() as *const [G; OUT_421]) }; __ret }, _ => aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[427].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[427].bump_multiplicity(__i)?; } record.function_queries[427].output_at(__i).to_array::() }, _ => aiur_fn_427(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_7]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_7]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[428].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i)?; } record.function_queries[428].output_at(__i).to_array::() }, _ => aiur_fn_428(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_7]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_7]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_7]; - record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_426] = [__v_7]; + record.function_queries[426].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 6; -const IN_421: usize = 6; -const OUT_421: usize = 1; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_427: usize = 6; +const IN_427: usize = 6; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], ExecError> { +) -> Result<[G; OUT_427], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } }; + record.checkpoint(427); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[425].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i)?; } record.function_queries[425].output_at(__i).to_array::() }, _ => aiur_fn_425(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[392].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i)?; } record.function_queries[392].output_at(__i).to_array::() }, _ => aiur_fn_392(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -37954,52 +39073,53 @@ fn aiur_fn_421( match __v_14.as_canonical_u64() { 6u64 => { let __v_26: G = (__v_20 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_8, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_27, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[426].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i)?; } record.function_queries[426].output_at(__i).to_array::() }, _ => aiur_fn_426(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_28]; - record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_427] = [__v_28]; + record.function_queries[427].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_26]; - record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_427] = [__v_26]; + record.function_queries[427].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_13]; - record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_427] = [__v_13]; + record.function_queries[427].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_422: usize = 5; -const IN_422: usize = 5; -const OUT_422: usize = 1; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_428: usize = 5; +const IN_428: usize = 5; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], ExecError> { +) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(428); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -38014,297 +39134,302 @@ fn aiur_fn_422( let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[410].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i)?; } record.function_queries[410].output_at(__i).to_array::() }, _ => aiur_fn_410(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_20, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[425].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i)?; } record.function_queries[425].output_at(__i).to_array::() }, _ => aiur_fn_425(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_21]; - record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_428] = [__v_21]; + record.function_queries[428].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_21]; - record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_428] = [__v_21]; + record.function_queries[428].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_18]; - record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_428] = [__v_18]; + record.function_queries[428].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_423: usize = 2; -const IN_423: usize = 2; -const OUT_423: usize = 1; -fn aiur_fn_423( - inp: [G; IN_423], +const INPUT_SIZE_429: usize = 2; +const IN_429: usize = 2; +const OUT_429: usize = 1; +fn aiur_fn_429( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], ExecError> { +) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(429); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_423] = [__v_0]; - record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_423] = [__v_0]; - record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_423] = [__v_0]; - record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_423] = [__v_0]; - record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_423] = [__v_0]; - record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_10, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_11]; - record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_429] = [__v_11]; + record.function_queries[429].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 2; -const IN_424: usize = 2; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_430: usize = 2; +const IN_430: usize = 2; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], ExecError> { +) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(430); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_0, __v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_5]; - record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_430] = [__v_5]; + record.function_queries[430].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_425: usize = 3; -const IN_425: usize = 3; -const OUT_425: usize = 1; -fn aiur_fn_425( - inp: [G; IN_425], +const INPUT_SIZE_431: usize = 3; +const IN_431: usize = 3; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], ExecError> { +) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(431); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_9, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_10]; - record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_431] = [__v_10]; + record.function_queries[431].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[426].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[432].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i)?; } record.function_queries[432].output_at(__i).to_array::() }, _ => aiur_fn_432(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_431] = [__v_7]; + record.function_queries[431].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[434].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i)?; } record.function_queries[434].output_at(__i).to_array::() }, _ => aiur_fn_434(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_431] = [__v_7]; + record.function_queries[431].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_9]; - record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_431] = [__v_9]; + record.function_queries[431].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[433].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[433].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[433].bump_multiplicity(__i)?; } record.function_queries[433].output_at(__i).to_array::() }, _ => aiur_fn_433(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_431] = [__v_7]; + record.function_queries[431].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_7]; - record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_431] = [__v_7]; + record.function_queries[431].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_426: usize = 3; -const IN_426: usize = 3; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_432: usize = 3; +const IN_432: usize = 3; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_426], ExecError> { +) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(432); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_1, __v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[381].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i)?; } record.function_queries[381].output_at(__i).to_array::() }, _ => aiur_fn_381(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_1, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_10]; - record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_432] = [__v_10]; + record.function_queries[432].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_6, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_13, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_14]; - record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_432] = [__v_14]; + record.function_queries[432].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_6, __v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_11, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_12]; - record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_432] = [__v_12]; + record.function_queries[432].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_427: usize = 5; -const IN_427: usize = 5; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_433: usize = 5; +const IN_433: usize = 5; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_427], ExecError> { +) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + record.checkpoint(433); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[385].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[391].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i)?; } record.function_queries[391].output_at(__i).to_array::() }, _ => aiur_fn_391(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_10, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_11]; - record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_433] = [__v_11]; + record.function_queries[433].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[392].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i)?; } record.function_queries[392].output_at(__i).to_array::() }, _ => aiur_fn_392(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; @@ -38320,32 +39445,32 @@ fn aiur_fn_427( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_8, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_29, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[431].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i)?; } record.function_queries[431].output_at(__i).to_array::() }, _ => aiur_fn_431(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_30]; - record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_433] = [__v_30]; + record.function_queries[433].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); - let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_29, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_30]; - record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_433] = [__v_30]; + record.function_queries[433].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(8); - let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_16, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_17]; - record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_433] = [__v_17]; + record.function_queries[433].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -38354,32 +39479,33 @@ fn aiur_fn_427( }) } -const INPUT_SIZE_428: usize = 5; -const IN_428: usize = 5; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +const INPUT_SIZE_434: usize = 5; +const IN_434: usize = 5; +const OUT_434: usize = 1; +fn aiur_fn_434( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_428], ExecError> { +) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } }; + record.checkpoint(434); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[396].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i)?; } record.function_queries[396].output_at(__i).to_array::() }, _ => aiur_fn_396(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[397].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i)?; } record.function_queries[397].output_at(__i).to_array::() }, _ => aiur_fn_397(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; @@ -38389,13 +39515,13 @@ fn aiur_fn_428( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_8, __v_12]; }, } }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[397].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i)?; } record.function_queries[397].output_at(__i).to_array::() }, _ => aiur_fn_397(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; @@ -38406,21 +39532,21 @@ fn aiur_fn_428( let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_8]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_8]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_428] = [__v_7]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_7]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -38435,43 +39561,43 @@ fn aiur_fn_428( let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_12, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[403].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i)?; } record.function_queries[403].output_at(__i).to_array::() }, _ => aiur_fn_403(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_22, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_23]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_23]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[398].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i)?; } record.function_queries[398].output_at(__i).to_array::() }, _ => aiur_fn_398(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_22, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_23]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_23]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_23]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -38482,10 +39608,10 @@ fn aiur_fn_428( let __v_23: G = (__v_22 + __v_13); let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_11, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_11, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[414].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i)?; } record.function_queries[414].output_at(__i).to_array::() }, _ => aiur_fn_414(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[406].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i)?; } record.function_queries[406].output_at(__i).to_array::() }, _ => aiur_fn_406(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; @@ -38500,46 +39626,46 @@ fn aiur_fn_428( let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_428] = [__v_25]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_25]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[410].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i)?; } record.function_queries[410].output_at(__i).to_array::() }, _ => aiur_fn_410(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_28, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_28, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_29]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_29]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_428] = [__v_28]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_28]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[413].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i)?; } record.function_queries[413].output_at(__i).to_array::() }, _ => aiur_fn_413(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_30, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_30, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_31]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_31]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_428] = [__v_28]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_28]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -38547,10 +39673,10 @@ fn aiur_fn_428( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_29]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_29]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -38558,10 +39684,10 @@ fn aiur_fn_428( } }, _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_21]; - record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_434] = [__v_21]; + record.function_queries[434].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -38570,92 +39696,94 @@ fn aiur_fn_428( }) } -const INPUT_SIZE_429: usize = 2; -const IN_429: usize = 2; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +const INPUT_SIZE_435: usize = 2; +const IN_435: usize = 2; +const OUT_435: usize = 1; +fn aiur_fn_435( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_429], ExecError> { +) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + record.checkpoint(435); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_2, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_6]; - record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_435] = [__v_6]; + record.function_queries[435].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_430: usize = 12; -const IN_430: usize = 12; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +const INPUT_SIZE_436: usize = 12; +const IN_436: usize = 12; +const OUT_436: usize = 1; +fn aiur_fn_436( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_430], ExecError> { +) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(436); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_430] = [__v_1]; - record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_436] = [__v_1]; + record.function_queries[436].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -38665,67 +39793,68 @@ fn aiur_fn_430( }) } -const INPUT_SIZE_431: usize = 12; -const IN_431: usize = 12; -const OUT_431: usize = 1; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_437: usize = 12; +const IN_437: usize = 12; +const OUT_437: usize = 1; +fn aiur_fn_437( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], ExecError> { +) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(437); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_431] = [__v_2]; - record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_437] = [__v_2]; + record.function_queries[437].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -38735,57 +39864,58 @@ fn aiur_fn_431( }) } -const INPUT_SIZE_432: usize = 2; -const IN_432: usize = 2; -const OUT_432: usize = 1; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_438: usize = 2; +const IN_438: usize = 2; +const OUT_438: usize = 1; +fn aiur_fn_438( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], ExecError> { +) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + record.checkpoint(438); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_8, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_12]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_438] = [__v_12]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_14]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_438] = [__v_14]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -38798,25 +39928,25 @@ fn aiur_fn_432( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[436].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i)?; } record.function_queries[436].output_at(__i).to_array::() }, _ => aiur_fn_436(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[437].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i)?; } record.function_queries[437].output_at(__i).to_array::() }, _ => aiur_fn_437(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_22, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_22, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_24]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_438] = [__v_24]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -38824,16 +39954,16 @@ fn aiur_fn_432( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_11, __v_6, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_14]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_438] = [__v_14]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -38841,10 +39971,10 @@ fn aiur_fn_432( match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_16, __v_6, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_19]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_438] = [__v_19]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -38856,68 +39986,68 @@ fn aiur_fn_432( }, 4u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(5); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_13]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_5, __v_10, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_438] = [__v_13]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[440].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i)?; } record.function_queries[440].output_at(__i).to_array::() }, _ => aiur_fn_440(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[440].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i)?; } record.function_queries[440].output_at(__i).to_array::() }, _ => aiur_fn_440(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[334].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i)?; } record.function_queries[334].output_at(__i).to_array::() }, _ => aiur_fn_334(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_15]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_438] = [__v_15]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_7, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_10]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_438] = [__v_10]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[387].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i)?; } record.function_queries[387].output_at(__i).to_array::() }, _ => aiur_fn_387(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_14]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_438] = [__v_14]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_432] = [__v_14]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_438] = [__v_14]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -38926,23 +40056,23 @@ fn aiur_fn_432( } }, 8u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -38961,9 +40091,9 @@ fn aiur_fn_432( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_24, __v_25, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; @@ -38982,15 +40112,15 @@ fn aiur_fn_432( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_33, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_33, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_44, __v_11, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[441].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i)?; } record.function_queries[441].output_at(__i).to_array::() }, _ => aiur_fn_441(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[442].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i)?; } record.function_queries[442].output_at(__i).to_array::() }, _ => aiur_fn_442(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __ret: [G; OUT_432] = [__v_47]; - record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_438] = [__v_47]; + record.function_queries[438].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -39015,53 +40145,54 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 2; -const IN_433: usize = 2; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_439: usize = 2; +const IN_439: usize = 2; +const OUT_439: usize = 1; +fn aiur_fn_439( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], ExecError> { +) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(439); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_6, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_10]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_439] = [__v_10]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_12]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_439] = [__v_12]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -39074,25 +40205,25 @@ fn aiur_fn_433( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[436].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i)?; } record.function_queries[436].output_at(__i).to_array::() }, _ => aiur_fn_436(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[437].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i)?; } record.function_queries[437].output_at(__i).to_array::() }, _ => aiur_fn_437(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_20, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_22]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_439] = [__v_22]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -39100,16 +40231,16 @@ fn aiur_fn_433( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_9, __v_4, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_12]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_439] = [__v_12]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -39117,10 +40248,10 @@ fn aiur_fn_433( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_14, __v_4, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_17]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_439] = [__v_17]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -39132,68 +40263,68 @@ fn aiur_fn_433( }, 4u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_11]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_439] = [__v_11]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[440].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i)?; } record.function_queries[440].output_at(__i).to_array::() }, _ => aiur_fn_440(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[440].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i)?; } record.function_queries[440].output_at(__i).to_array::() }, _ => aiur_fn_440(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[334].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i)?; } record.function_queries[334].output_at(__i).to_array::() }, _ => aiur_fn_334(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_13]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_439] = [__v_13]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_8]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_439] = [__v_8]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[387].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i)?; } record.function_queries[387].output_at(__i).to_array::() }, _ => aiur_fn_387(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_12]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_439] = [__v_12]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_433] = [__v_12]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_439] = [__v_12]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -39202,23 +40333,23 @@ fn aiur_fn_433( } }, 8u64 => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -39237,9 +40368,9 @@ fn aiur_fn_433( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_22, __v_23, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -39258,15 +40389,15 @@ fn aiur_fn_433( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_31, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_31, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_42, __v_9, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[441].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i)?; } record.function_queries[441].output_at(__i).to_array::() }, _ => aiur_fn_441(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[442].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i)?; } record.function_queries[442].output_at(__i).to_array::() }, _ => aiur_fn_442(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_45]; - record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_439] = [__v_45]; + record.function_queries[439].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -39291,43 +40422,44 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 2; -const IN_434: usize = 2; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_440: usize = 2; +const IN_440: usize = 2; +const OUT_440: usize = 1; +fn aiur_fn_440( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], ExecError> { +) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + record.checkpoint(440); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_434] = [__v_4]; - record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_440] = [__v_4]; + record.function_queries[440].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_434] = [__v_9]; - record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_440] = [__v_9]; + record.function_queries[440].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -39339,48 +40471,49 @@ fn aiur_fn_434( }) } -const INPUT_SIZE_435: usize = 3; -const IN_435: usize = 3; -const OUT_435: usize = 1; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_441: usize = 3; +const IN_441: usize = 3; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_435], ExecError> { +) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(441); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_435] = [__v_0]; - record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_441] = [__v_0]; + record.function_queries[441].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_11, __v_9, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[441].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i)?; } record.function_queries[441].output_at(__i).to_array::() }, _ => aiur_fn_441(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_435] = [__v_14]; - record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_441] = [__v_14]; + record.function_queries[441].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -39397,22 +40530,23 @@ fn aiur_fn_435( }) } -const INPUT_SIZE_436: usize = 5; -const IN_436: usize = 5; -const OUT_436: usize = 1; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_442: usize = 5; +const IN_442: usize = 5; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(442); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -39422,22 +40556,22 @@ fn aiur_fn_436( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_436] = [__v_6]; - record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_442] = [__v_6]; + record.function_queries[442].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); - let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_7, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[442].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i)?; } record.function_queries[442].output_at(__i).to_array::() }, _ => aiur_fn_442(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_16]; - record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_442] = [__v_16]; + record.function_queries[442].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -39449,70 +40583,71 @@ fn aiur_fn_436( }) } -const INPUT_SIZE_437: usize = 2; -const IN_437: usize = 2; -const OUT_437: usize = 1; -fn aiur_fn_437( - inp: [G; IN_437], +const INPUT_SIZE_443: usize = 2; +const IN_443: usize = 2; +const OUT_443: usize = 1; +fn aiur_fn_443( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_437], ExecError> { +) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(443); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_437] = [__v_8]; - record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_443] = [__v_8]; + record.function_queries[443].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_8]; - record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_443] = [__v_8]; + record.function_queries[443].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_8]; - record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_443] = [__v_8]; + record.function_queries[443].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_9]; - record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_443] = [__v_9]; + record.function_queries[443].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[443].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i)?; } record.function_queries[443].output_at(__i).to_array::() }, _ => aiur_fn_443(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_9]; - record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_443] = [__v_9]; + record.function_queries[443].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -39529,50 +40664,51 @@ fn aiur_fn_437( }) } -const INPUT_SIZE_438: usize = 3; -const IN_438: usize = 3; -const OUT_438: usize = 1; -fn aiur_fn_438( - inp: [G; IN_438], +const INPUT_SIZE_444: usize = 3; +const IN_444: usize = 3; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_438], ExecError> { +) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(444); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_438] = [__v_4]; - record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_444] = [__v_4]; + record.function_queries[444].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[345].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i)?; } record.function_queries[345].output_at(__i).to_array::() }, _ => aiur_fn_345(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[446].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i)?; } record.function_queries[446].output_at(__i).to_array::() }, _ => aiur_fn_446(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_10]; - record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_444] = [__v_10]; + record.function_queries[444].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[445].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i)?; } record.function_queries[445].output_at(__i).to_array::() }, _ => aiur_fn_445(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_7]; - record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_444] = [__v_7]; + record.function_queries[444].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -39581,157 +40717,161 @@ fn aiur_fn_438( }) } -const INPUT_SIZE_439: usize = 4; -const IN_439: usize = 4; -const OUT_439: usize = 1; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_445: usize = 4; +const IN_445: usize = 4; +const OUT_445: usize = 1; +fn aiur_fn_445( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_439], ExecError> { +) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(445); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[446].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i)?; } record.function_queries[446].output_at(__i).to_array::() }, _ => aiur_fn_446(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_12]; - record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_445] = [__v_12]; + record.function_queries[445].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_10, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_3 - __v_10); - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_12, __v_14, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[446].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i)?; } record.function_queries[446].output_at(__i).to_array::() }, _ => aiur_fn_446(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_439] = [__v_18]; - record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_445] = [__v_18]; + record.function_queries[445].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_440: usize = 3; -const IN_440: usize = 3; -const OUT_440: usize = 1; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_446: usize = 3; +const IN_446: usize = 3; +const OUT_446: usize = 1; +fn aiur_fn_446( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], ExecError> { +) -> Result<[G; OUT_446], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(446); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[447].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[447].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[447].bump_multiplicity(__i)?; } record.function_queries[447].output_at(__i).to_array::() }, _ => aiur_fn_447(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_4]; - record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_446] = [__v_4]; + record.function_queries[446].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_1, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[447].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[447].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[447].bump_multiplicity(__i)?; } record.function_queries[447].output_at(__i).to_array::() }, _ => aiur_fn_447(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_4]; - record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_446] = [__v_4]; + record.function_queries[446].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_441: usize = 3; -const IN_441: usize = 3; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_447: usize = 3; +const IN_447: usize = 3; +const OUT_447: usize = 1; +fn aiur_fn_447( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_441], ExecError> { +) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; + record.checkpoint(447); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[448].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i)?; } record.function_queries[448].output_at(__i).to_array::() }, _ => aiur_fn_448(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_441] = [__v_4]; - record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_447] = [__v_4]; + record.function_queries[447].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[449].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i); } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[455].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[455].bump_multiplicity(__i)?; } record.function_queries[455].output_at(__i).to_array::() }, _ => aiur_fn_455(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_4]; - record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_447] = [__v_4]; + record.function_queries[447].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_442: usize = 3; -const IN_442: usize = 3; -const OUT_442: usize = 1; -fn aiur_fn_442( - inp: [G; IN_442], +const INPUT_SIZE_448: usize = 3; +const IN_448: usize = 3; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_442], ExecError> { +) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(448); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -39741,33 +40881,33 @@ fn aiur_fn_442( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[443].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i)?; } record.function_queries[443].output_at(__i).to_array::() }, _ => aiur_fn_443(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_17]; - record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_448] = [__v_17]; + record.function_queries[448].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_4, __v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[449].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i)?; } record.function_queries[449].output_at(__i).to_array::() }, _ => aiur_fn_449(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_442] = [__v_20]; - record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_448] = [__v_20]; + record.function_queries[448].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_20]; - record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_448] = [__v_20]; + record.function_queries[448].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -39776,95 +40916,96 @@ fn aiur_fn_442( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_16]; - record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_448] = [__v_16]; + record.function_queries[448].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_15]; - record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_448] = [__v_15]; + record.function_queries[448].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_11]; - record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_448] = [__v_11]; + record.function_queries[448].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_443: usize = 3; -const IN_443: usize = 3; -const OUT_443: usize = 1; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_449: usize = 3; +const IN_449: usize = 3; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], ExecError> { +) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(449); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_443] = [__v_9]; - record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_449] = [__v_9]; + record.function_queries[449].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_9]; - record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_449] = [__v_9]; + record.function_queries[449].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_9]; - record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_449] = [__v_9]; + record.function_queries[449].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_7, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_443] = [__v_10]; - record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_449] = [__v_10]; + record.function_queries[449].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[449].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i)?; } record.function_queries[449].output_at(__i).to_array::() }, _ => aiur_fn_449(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_10]; - record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_449] = [__v_10]; + record.function_queries[449].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -39881,18 +41022,19 @@ fn aiur_fn_443( }) } -const INPUT_SIZE_444: usize = 1; -const IN_444: usize = 1; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_450: usize = 1; +const IN_450: usize = 1; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_444], ExecError> { +) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(450); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -39901,51 +41043,52 @@ fn aiur_fn_444( 7u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_5]; - record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_450] = [__v_5]; + record.function_queries[450].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_5]; - record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_450] = [__v_5]; + record.function_queries[450].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[149].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i)?; } record.function_queries[149].output_at(__i).to_array::() }, _ => aiur_fn_149(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_6]; - record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_450] = [__v_6]; + record.function_queries[450].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_5]; - record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_450] = [__v_5]; + record.function_queries[450].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_445: usize = 1; -const IN_445: usize = 1; -const OUT_445: usize = 3; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_451: usize = 1; +const IN_451: usize = 1; +const OUT_451: usize = 3; +fn aiur_fn_451( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], ExecError> { +) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(451); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -39957,75 +41100,75 @@ fn aiur_fn_445( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_5, __v_9, __v_3]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_451] = [__v_5, __v_9, __v_3]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_5, __v_0, __v_8]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[451].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i)?; } record.function_queries[451].output_at(__i).to_array::() }, _ => aiur_fn_451(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_14, __v_12, __v_15]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_451] = [__v_14, __v_12, __v_15]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_11, __v_0, __v_14]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_11, __v_0, __v_14]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -40034,23 +41177,23 @@ fn aiur_fn_445( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[451].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i)?; } record.function_queries[451].output_at(__i).to_array::() }, _ => aiur_fn_451(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; match __v_19.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_21, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_21, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_445] = [__v_22, __v_20, __v_23]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_451] = [__v_22, __v_20, __v_23]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_445] = [__v_22, __v_7, __v_17]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_451] = [__v_22, __v_7, __v_17]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40059,9 +41202,9 @@ fn aiur_fn_445( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_19, __v_0, __v_22]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40070,9 +41213,9 @@ fn aiur_fn_445( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_19, __v_0, __v_22]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40081,9 +41224,9 @@ fn aiur_fn_445( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_15, __v_0, __v_18]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_15, __v_0, __v_18]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40092,9 +41235,9 @@ fn aiur_fn_445( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_13, __v_0, __v_16]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_13, __v_0, __v_16]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40103,9 +41246,9 @@ fn aiur_fn_445( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_9, __v_0, __v_12]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_9, __v_0, __v_12]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40114,47 +41257,48 @@ fn aiur_fn_445( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8]; - record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_451] = [__v_5, __v_0, __v_8]; + record.function_queries[451].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_446: usize = 3; -const IN_446: usize = 3; -const OUT_446: usize = 2; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_452: usize = 3; +const IN_452: usize = 3; +const OUT_452: usize = 2; +fn aiur_fn_452( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_446], ExecError> { +) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[444].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i); } let __ret: [G; OUT_444] = unsafe { *(record.function_queries[444].output_at(__i).as_ptr() as *const [G; OUT_444]) }; __ret }, _ => aiur_fn_444(__args, record, io_buffer, __cu)? } }; + record.checkpoint(452); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[450].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i)?; } record.function_queries[450].output_at(__i).to_array::() }, _ => aiur_fn_450(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[444].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i); } let __ret: [G; OUT_444] = unsafe { *(record.function_queries[444].output_at(__i).as_ptr() as *const [G; OUT_444]) }; __ret }, _ => aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[450].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i)?; } record.function_queries[450].output_at(__i).to_array::() }, _ => aiur_fn_450(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_446] = [__v_6, __v_7]; - record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_452] = [__v_6, __v_7]; + record.function_queries[452].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[451].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i)?; } record.function_queries[451].output_at(__i).to_array::() }, _ => aiur_fn_451(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[451].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i)?; } record.function_queries[451].output_at(__i).to_array::() }, _ => aiur_fn_451(__key, 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]; @@ -40163,27 +41307,27 @@ fn aiur_fn_446( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_446] = [__v_13, __v_14]; - record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_452] = [__v_13, __v_14]; + record.function_queries[452].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[340].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i)?; } record.function_queries[340].output_at(__i).to_array::() }, _ => aiur_fn_340(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_446] = [__v_14, __v_15]; - record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_452] = [__v_14, __v_15]; + record.function_queries[452].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_7, __v_10, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_446] = [__v_14, __v_15]; - record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_452] = [__v_14, __v_15]; + record.function_queries[452].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40194,53 +41338,55 @@ fn aiur_fn_446( }) } -const INPUT_SIZE_447: usize = 3; -const IN_447: usize = 3; -const OUT_447: usize = 1; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_453: usize = 3; +const IN_453: usize = 3; +const OUT_453: usize = 1; +fn aiur_fn_453( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], ExecError> { +) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } }; + record.checkpoint(453); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[454].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i)?; } record.function_queries[454].output_at(__i).to_array::() }, _ => aiur_fn_454(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_447] = [__v_4]; - record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_453] = [__v_4]; + record.function_queries[453].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[454].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i)?; } record.function_queries[454].output_at(__i).to_array::() }, _ => aiur_fn_454(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_447] = [__v_4]; - record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_453] = [__v_4]; + record.function_queries[453].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_448: usize = 3; -const IN_448: usize = 3; -const OUT_448: usize = 1; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_454: usize = 3; +const IN_454: usize = 3; +const OUT_454: usize = 1; +fn aiur_fn_454( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], ExecError> { +) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(454); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -40249,48 +41395,49 @@ fn aiur_fn_448( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[230].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i)?; } record.function_queries[230].output_at(__i).to_array::() }, _ => aiur_fn_230(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_7, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_448] = [__v_9]; - record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_454] = [__v_9]; + record.function_queries[454].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_448] = [__v_7]; - record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_454] = [__v_7]; + record.function_queries[454].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_448] = [__v_7]; - record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_454] = [__v_7]; + record.function_queries[454].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_449: usize = 3; -const IN_449: usize = 3; -const OUT_449: usize = 1; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_455: usize = 3; +const IN_455: usize = 3; +const OUT_455: usize = 1; +fn aiur_fn_455( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], ExecError> { +) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } }; + record.checkpoint(455); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[454].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i)?; } record.function_queries[454].output_at(__i).to_array::() }, _ => aiur_fn_454(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { @@ -40298,7 +41445,7 @@ fn aiur_fn_449( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_1, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[454].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i)?; } record.function_queries[454].output_at(__i).to_array::() }, _ => aiur_fn_454(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -40308,71 +41455,72 @@ fn aiur_fn_449( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_449] = [__v_5]; - record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_455] = [__v_5]; + record.function_queries[455].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[456].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i)?; } record.function_queries[456].output_at(__i).to_array::() }, _ => aiur_fn_456(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_449] = [__v_5]; - record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_455] = [__v_5]; + record.function_queries[455].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_450: usize = 3; -const IN_450: usize = 3; -const OUT_450: usize = 1; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_456: usize = 3; +const IN_456: usize = 3; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], ExecError> { +) -> Result<[G; OUT_456], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } }; + record.checkpoint(456); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[425].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i)?; } record.function_queries[425].output_at(__i).to_array::() }, _ => aiur_fn_425(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[425].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i)?; } record.function_queries[425].output_at(__i).to_array::() }, _ => aiur_fn_425(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_6]; - record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_456] = [__v_6]; + record.function_queries[456].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[452].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[458].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i)?; } record.function_queries[458].output_at(__i).to_array::() }, _ => aiur_fn_458(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_7]; - record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_456] = [__v_7]; + record.function_queries[456].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[448].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i)?; } record.function_queries[448].output_at(__i).to_array::() }, _ => aiur_fn_448(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_450] = [__v_8]; - record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_456] = [__v_8]; + record.function_queries[456].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[457].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[457].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[457].bump_multiplicity(__i)?; } record.function_queries[457].output_at(__i).to_array::() }, _ => aiur_fn_457(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_450] = [__v_8]; - record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_456] = [__v_8]; + record.function_queries[456].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40383,58 +41531,59 @@ fn aiur_fn_450( }) } -const INPUT_SIZE_451: usize = 5; -const IN_451: usize = 5; -const OUT_451: usize = 1; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_457: usize = 5; +const IN_457: usize = 5; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], ExecError> { +) -> Result<[G; OUT_457], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + record.checkpoint(457); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_8]; - record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_457] = [__v_8]; + record.function_queries[457].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[452].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[458].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i)?; } record.function_queries[458].output_at(__i).to_array::() }, _ => aiur_fn_458(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_9]; - record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_457] = [__v_9]; + record.function_queries[457].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_5, __v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[448].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i)?; } record.function_queries[448].output_at(__i).to_array::() }, _ => aiur_fn_448(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_451] = [__v_10]; - record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_457] = [__v_10]; + record.function_queries[457].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[459].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i)?; } record.function_queries[459].output_at(__i).to_array::() }, _ => aiur_fn_459(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_451] = [__v_10]; - record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_457] = [__v_10]; + record.function_queries[457].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40445,220 +41594,222 @@ fn aiur_fn_451( }) } -const INPUT_SIZE_452: usize = 3; -const IN_452: usize = 3; -const OUT_452: usize = 1; -fn aiur_fn_452( - inp: [G; IN_452], +const INPUT_SIZE_458: usize = 3; +const IN_458: usize = 3; +const OUT_458: usize = 1; +fn aiur_fn_458( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { +) -> Result<[G; OUT_458], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(458); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_11]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_11]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_11]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_9, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_14]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_14]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_12]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_12]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_11]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_9, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_452] = [__v_14]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_14]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_12]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_12]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_11]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_11]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_7]; - record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_458] = [__v_7]; + record.function_queries[458].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_453: usize = 5; -const IN_453: usize = 5; -const OUT_453: usize = 1; -fn aiur_fn_453( - inp: [G; IN_453], +const INPUT_SIZE_459: usize = 5; +const IN_459: usize = 5; +const OUT_459: usize = 1; +fn aiur_fn_459( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_453], ExecError> { +) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(459); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = (__v_2 - __v_3); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_6]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_6]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[473].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i)?; } record.function_queries[473].output_at(__i).to_array::() }, _ => aiur_fn_473(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_7]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_7]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[471].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i)?; } record.function_queries[471].output_at(__i).to_array::() }, _ => aiur_fn_471(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_8]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_8]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[467].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i)?; } record.function_queries[467].output_at(__i).to_array::() }, _ => aiur_fn_467(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_9]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_9]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[467].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i)?; } record.function_queries[467].output_at(__i).to_array::() }, _ => aiur_fn_467(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_10]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_10]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[452].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i)?; } record.function_queries[452].output_at(__i).to_array::() }, _ => aiur_fn_452(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_453] = [__v_11]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_11]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_2, __v_3, __v_12, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_453] = [__v_16]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_16]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[454].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i); } let __ret: [G; OUT_454] = unsafe { *(record.function_queries[454].output_at(__i).as_ptr() as *const [G; OUT_454]) }; __ret }, _ => aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[460].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[460].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[460].bump_multiplicity(__i)?; } record.function_queries[460].output_at(__i).to_array::() }, _ => aiur_fn_460(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_453] = [__v_16]; - record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_459] = [__v_16]; + record.function_queries[459].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40677,47 +41828,48 @@ fn aiur_fn_453( }) } -const INPUT_SIZE_454: usize = 5; -const IN_454: usize = 5; -const OUT_454: usize = 1; -fn aiur_fn_454( - inp: [G; IN_454], +const INPUT_SIZE_460: usize = 5; +const IN_460: usize = 5; +const OUT_460: usize = 1; +fn aiur_fn_460( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_454], ExecError> { +) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(460); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(8); - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_2, __v_3, __v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_8]; - record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_460] = [__v_8]; + record.function_queries[460].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[462].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i)?; } record.function_queries[462].output_at(__i).to_array::() }, _ => aiur_fn_462(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_9]; - record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_460] = [__v_9]; + record.function_queries[460].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[460].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[460].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[460].bump_multiplicity(__i); } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_0, __v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[466].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i)?; } record.function_queries[466].output_at(__i).to_array::() }, _ => aiur_fn_466(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_454] = [__v_9]; - record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_460] = [__v_9]; + record.function_queries[460].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40726,57 +41878,58 @@ fn aiur_fn_454( }) } -const INPUT_SIZE_455: usize = 3; -const IN_455: usize = 3; -const OUT_455: usize = 1; -fn aiur_fn_455( - inp: [G; IN_455], +const INPUT_SIZE_461: usize = 3; +const IN_461: usize = 3; +const OUT_461: usize = 1; +fn aiur_fn_461( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_455], ExecError> { +) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(461); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_8]; - record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_461] = [__v_8]; + record.function_queries[461].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_13 - __v_17); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); @@ -40786,40 +41939,40 @@ fn aiur_fn_455( let __v_25: G = (__v_19 * __v_24); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_4, __v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[449].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i)?; } record.function_queries[449].output_at(__i).to_array::() }, _ => aiur_fn_449(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_26]; - record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_461] = [__v_26]; + record.function_queries[461].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_26]; - record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_461] = [__v_26]; + record.function_queries[461].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_19]; - record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_461] = [__v_19]; + record.function_queries[461].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_15]; - record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_461] = [__v_15]; + record.function_queries[461].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_11]; - record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_461] = [__v_11]; + record.function_queries[461].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40828,45 +41981,46 @@ fn aiur_fn_455( }) } -const INPUT_SIZE_456: usize = 3; -const IN_456: usize = 3; -const OUT_456: usize = 1; -fn aiur_fn_456( - inp: [G; IN_456], +const INPUT_SIZE_462: usize = 3; +const IN_462: usize = 3; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_456], ExecError> { +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(462); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(8); - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_456] = [__v_6]; - record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_462] = [__v_6]; + record.function_queries[462].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[455].bump_multiplicity(__i); } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[461].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i)?; } record.function_queries[461].output_at(__i).to_array::() }, _ => aiur_fn_461(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_456] = [__v_7]; - record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_462] = [__v_7]; + record.function_queries[462].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[457].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[457].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[457].bump_multiplicity(__i); } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[463].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i)?; } record.function_queries[463].output_at(__i).to_array::() }, _ => aiur_fn_463(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_456] = [__v_7]; - record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_462] = [__v_7]; + record.function_queries[462].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -40875,100 +42029,102 @@ fn aiur_fn_456( }) } -const INPUT_SIZE_457: usize = 3; -const IN_457: usize = 3; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], +const INPUT_SIZE_463: usize = 3; +const IN_463: usize = 3; +const OUT_463: usize = 1; +fn aiur_fn_463( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { +) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(463); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_4, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[462].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i)?; } record.function_queries[462].output_at(__i).to_array::() }, _ => aiur_fn_462(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_5, __v_9, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[462].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i)?; } record.function_queries[462].output_at(__i).to_array::() }, _ => aiur_fn_462(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_12]; - record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_463] = [__v_12]; + record.function_queries[463].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_12]; - record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_463] = [__v_12]; + record.function_queries[463].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_11]; - record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_463] = [__v_11]; + record.function_queries[463].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_7]; - record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_463] = [__v_7]; + record.function_queries[463].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_458: usize = 4; -const IN_458: usize = 4; -const OUT_458: usize = 2; -fn aiur_fn_458( - inp: [G; IN_458], +const INPUT_SIZE_464: usize = 4; +const IN_464: usize = 4; +const OUT_464: usize = 2; +fn aiur_fn_464( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_458], ExecError> { +) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(464); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 - __v_1); match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_458] = [__v_5, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_5, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -40979,288 +42135,288 @@ fn aiur_fn_458( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_458] = [__v_14, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_14, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_14, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_14, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_13, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_7, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[443].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i)?; } record.function_queries[443].output_at(__i).to_array::() }, _ => aiur_fn_443(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_14, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_14, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_14, __v_15]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_14, __v_15]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_6, __v_10, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_7, __v_11, __v_14, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_15, __v_16]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_15, __v_16]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_15, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_6, __v_10, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_7, __v_11, __v_14, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_17, __v_18]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_17, __v_18]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_15, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_6, __v_10, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_7, __v_11, __v_14, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_17, __v_18]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_17, __v_18]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_15, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 7u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_6, __v_7, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[342].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[342].bump_multiplicity(__i)?; } record.function_queries[342].output_at(__i).to_array::() }, _ => aiur_fn_342(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_458] = [__v_13, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8, __v_12, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_15, __v_16]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_15, __v_16]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_15, __v_2]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_15, __v_2]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_14, __v_15]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_14, __v_15]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_13, __v_14]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_13, __v_14]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[465].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i)?; } record.function_queries[465].output_at(__i).to_array::() }, _ => aiur_fn_465(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_458] = [__v_9, __v_10]; - record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_464] = [__v_9, __v_10]; + record.function_queries[464].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -41269,72 +42425,73 @@ fn aiur_fn_458( }) } -const INPUT_SIZE_459: usize = 4; -const IN_459: usize = 4; -const OUT_459: usize = 2; -fn aiur_fn_459( - inp: [G; IN_459], +const INPUT_SIZE_465: usize = 4; +const IN_465: usize = 4; +const OUT_465: usize = 2; +fn aiur_fn_465( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_459], ExecError> { +) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(465); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_4, __v_5]; - record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_465] = [__v_4, __v_5]; + record.function_queries[465].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_9, __v_5]; - record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_465] = [__v_9, __v_5]; + record.function_queries[465].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_6, __v_7, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[452].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i)?; } record.function_queries[452].output_at(__i).to_array::() }, _ => aiur_fn_452(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_459] = [__v_10, __v_5]; - record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_465] = [__v_10, __v_5]; + record.function_queries[465].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_6, __v_7, __v_11, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_459] = [__v_15, __v_5]; - record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_465] = [__v_15, __v_5]; + record.function_queries[465].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_13, __v_14, __v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[464].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i)?; } record.function_queries[464].output_at(__i).to_array::() }, _ => aiur_fn_464(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_459] = [__v_15, __v_16]; - record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_465] = [__v_15, __v_16]; + record.function_queries[465].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -41347,96 +42504,97 @@ fn aiur_fn_459( }) } -const INPUT_SIZE_460: usize = 3; -const IN_460: usize = 3; -const OUT_460: usize = 1; -fn aiur_fn_460( - inp: [G; IN_460], +const INPUT_SIZE_466: usize = 3; +const IN_466: usize = 3; +const OUT_466: usize = 1; +fn aiur_fn_466( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_460], ExecError> { +) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(466); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_6]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_6]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[473].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i)?; } record.function_queries[473].output_at(__i).to_array::() }, _ => aiur_fn_473(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_7]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_7]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[471].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i)?; } record.function_queries[471].output_at(__i).to_array::() }, _ => aiur_fn_471(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_8]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_8]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[467].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i)?; } record.function_queries[467].output_at(__i).to_array::() }, _ => aiur_fn_467(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_9]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_9]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_4, __v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[467].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i)?; } record.function_queries[467].output_at(__i).to_array::() }, _ => aiur_fn_467(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_10]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_10]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[452].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i)?; } record.function_queries[452].output_at(__i).to_array::() }, _ => aiur_fn_452(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_460] = [__v_11]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_11]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[470].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[470].bump_multiplicity(__i)?; } record.function_queries[470].output_at(__i).to_array::() }, _ => aiur_fn_470(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_460] = [__v_13]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_13]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_3, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[476].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i)?; } record.function_queries[476].output_at(__i).to_array::() }, _ => aiur_fn_476(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_460] = [__v_13]; - record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_466] = [__v_13]; + record.function_queries[466].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -41455,32 +42613,33 @@ fn aiur_fn_460( }) } -const INPUT_SIZE_461: usize = 3; -const IN_461: usize = 3; -const OUT_461: usize = 1; -fn aiur_fn_461( - inp: [G; IN_461], +const INPUT_SIZE_467: usize = 3; +const IN_467: usize = 3; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_461], ExecError> { +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(467); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -41495,15 +42654,15 @@ fn aiur_fn_461( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[291].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i)?; } record.function_queries[291].output_at(__i).to_array::() }, _ => aiur_fn_291(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -41526,42 +42685,42 @@ fn aiur_fn_461( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_43]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_43]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[469].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i)?; } record.function_queries[469].output_at(__i).to_array::() }, _ => aiur_fn_469(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[416].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i)?; } record.function_queries[416].output_at(__i).to_array::() }, _ => aiur_fn_416(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_45]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_45]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_45, __v_46, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_48]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_48]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[468].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i)?; } record.function_queries[468].output_at(__i).to_array::() }, _ => aiur_fn_468(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_49]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_49]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -41572,85 +42731,86 @@ fn aiur_fn_461( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_38]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_38]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_25]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_25]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_22]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_22]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_461] = [__v_9]; - record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_467] = [__v_9]; + record.function_queries[467].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_462: usize = 7; -const IN_462: usize = 7; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], +const INPUT_SIZE_468: usize = 7; +const IN_468: usize = 7; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(468); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; let __v_7: G = (__v_2 - __v_5); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_462] = [__v_8]; - record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_468] = [__v_8]; + record.function_queries[468].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); - let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_9, __v_11, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_462] = [__v_13]; - record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[468].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i)?; } record.function_queries[468].output_at(__i).to_array::() }, _ => aiur_fn_468(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_15]; - record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_468] = [__v_15]; + record.function_queries[468].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -41659,19 +42819,20 @@ fn aiur_fn_462( }) } -const INPUT_SIZE_463: usize = 2; -const IN_463: usize = 2; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], +const INPUT_SIZE_469: usize = 2; +const IN_469: usize = 2; +const OUT_469: usize = 1; +fn aiur_fn_469( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; + record.checkpoint(469); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[295].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i)?; } record.function_queries[295].output_at(__i).to_array::() }, _ => aiur_fn_295(__key, 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]; @@ -41684,47 +42845,48 @@ fn aiur_fn_463( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_14, __v_17, __v_20, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[73].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i)?; } record.function_queries[73].output_at(__i).to_array::() }, _ => aiur_fn_73(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_463] = [__v_25]; - record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_469] = [__v_25]; + record.function_queries[469].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_464: usize = 3; -const IN_464: usize = 3; -const OUT_464: usize = 1; -fn aiur_fn_464( - inp: [G; IN_464], +const INPUT_SIZE_470: usize = 3; +const IN_470: usize = 3; +const OUT_470: usize = 1; +fn aiur_fn_470( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_464], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(470); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -41732,37 +42894,37 @@ fn aiur_fn_464( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_464] = [__v_11]; - record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_470] = [__v_11]; + record.function_queries[470].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_4, __v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[474].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i)?; } record.function_queries[474].output_at(__i).to_array::() }, _ => aiur_fn_474(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_464] = [__v_11]; - record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_470] = [__v_11]; + record.function_queries[470].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_8, __v_9, __v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[474].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i)?; } record.function_queries[474].output_at(__i).to_array::() }, _ => aiur_fn_474(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_464] = [__v_11]; - record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_470] = [__v_11]; + record.function_queries[470].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_464] = [__v_11]; - record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_470] = [__v_11]; + record.function_queries[470].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -41771,69 +42933,71 @@ fn aiur_fn_464( }) } -const INPUT_SIZE_465: usize = 3; -const IN_465: usize = 3; -const OUT_465: usize = 1; -fn aiur_fn_465( - inp: [G; IN_465], +const INPUT_SIZE_471: usize = 3; +const IN_471: usize = 3; +const OUT_471: usize = 1; +fn aiur_fn_471( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_465], ExecError> { +) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + record.checkpoint(471); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[472].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i)?; } record.function_queries[472].output_at(__i).to_array::() }, _ => aiur_fn_472(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_465] = [__v_6]; - record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_471] = [__v_6]; + record.function_queries[471].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_7]; - record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_471] = [__v_7]; + record.function_queries[471].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_466: usize = 1; -const IN_466: usize = 1; -const OUT_466: usize = 1; -fn aiur_fn_466( - inp: [G; IN_466], +const INPUT_SIZE_472: usize = 1; +const IN_472: usize = 1; +const OUT_472: usize = 1; +fn aiur_fn_472( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_466], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(472); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -41855,9 +43019,9 @@ fn aiur_fn_466( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_15, __v_16, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_24: G = __loaded[0]; let __v_25: G = __loaded[1]; let __v_26: G = __loaded[2]; @@ -41875,180 +43039,183 @@ fn aiur_fn_466( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_466] = [__v_36]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_36]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_36]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_36]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_36]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_36]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_22]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_22]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_20]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_20]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_20]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_20]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_466] = [__v_7]; - record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_472] = [__v_7]; + record.function_queries[472].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_467: usize = 3; -const IN_467: usize = 3; -const OUT_467: usize = 1; -fn aiur_fn_467( - inp: [G; IN_467], +const INPUT_SIZE_473: usize = 3; +const IN_473: usize = 3; +const OUT_473: usize = 1; +fn aiur_fn_473( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { +) -> Result<[G; OUT_473], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + record.checkpoint(473); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[475].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i)?; } record.function_queries[475].output_at(__i).to_array::() }, _ => aiur_fn_475(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_467] = [__v_5]; - record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_473] = [__v_5]; + record.function_queries[473].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_467] = [__v_6]; - record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_473] = [__v_6]; + record.function_queries[473].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_468: usize = 4; -const IN_468: usize = 4; -const OUT_468: usize = 1; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_474: usize = 4; +const IN_474: usize = 4; +const OUT_474: usize = 1; +fn aiur_fn_474( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_468], ExecError> { +) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + record.checkpoint(474); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_7, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_11]; - record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_474] = [__v_11]; + record.function_queries[474].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_2, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(3); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1, __v_20, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_468] = [__v_23]; - record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_474] = [__v_23]; + record.function_queries[474].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_468] = [__v_10]; - record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_474] = [__v_10]; + record.function_queries[474].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_469: usize = 2; -const IN_469: usize = 2; -const OUT_469: usize = 1; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_475: usize = 2; +const IN_475: usize = 2; +const OUT_475: usize = 1; +fn aiur_fn_475( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } }; + record.checkpoint(475); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[438].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i)?; } record.function_queries[438].output_at(__i).to_array::() }, _ => aiur_fn_438(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -42057,65 +43224,67 @@ fn aiur_fn_469( 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_469] = [__v_11]; - record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_475] = [__v_11]; + record.function_queries[475].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_469] = [__v_8]; - record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_475] = [__v_8]; + record.function_queries[475].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_470: usize = 3; -const IN_470: usize = 3; -const OUT_470: usize = 1; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_476: usize = 3; +const IN_476: usize = 3; +const OUT_476: usize = 1; +fn aiur_fn_476( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_470], ExecError> { +) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[471].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => aiur_fn_471(__args, record, io_buffer, __cu)? } }; + record.checkpoint(476); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[477].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i)?; } record.function_queries[477].output_at(__i).to_array::() }, _ => aiur_fn_477(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_470] = [__v_3]; - record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_476] = [__v_3]; + record.function_queries[476].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_471: usize = 3; -const IN_471: usize = 3; -const OUT_471: usize = 1; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_477: usize = 3; +const IN_477: usize = 3; +const OUT_477: usize = 1; +fn aiur_fn_477( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_477], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(477); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -42126,117 +43295,117 @@ fn aiur_fn_471( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[443].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i)?; } record.function_queries[443].output_at(__i).to_array::() }, _ => aiur_fn_443(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[490].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i)?; } record.function_queries[490].output_at(__i).to_array::() }, _ => aiur_fn_490(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[490].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i)?; } record.function_queries[490].output_at(__i).to_array::() }, _ => aiur_fn_490(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[490].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i)?; } record.function_queries[490].output_at(__i).to_array::() }, _ => aiur_fn_490(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_9, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[490].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i)?; } record.function_queries[490].output_at(__i).to_array::() }, _ => aiur_fn_490(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_13]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_13]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_471] = [__v_13]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_13]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42244,123 +43413,123 @@ fn aiur_fn_471( } }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[490].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i)?; } record.function_queries[490].output_at(__i).to_array::() }, _ => aiur_fn_490(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_9, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_14]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_14]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_4, __v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[474].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i)?; } record.function_queries[474].output_at(__i).to_array::() }, _ => aiur_fn_474(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_9, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_14]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_14]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_7]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_7]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[342].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[342].bump_multiplicity(__i)?; } record.function_queries[342].output_at(__i).to_array::() }, _ => aiur_fn_342(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[399].bump_multiplicity(__i); } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[405].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[405].bump_multiplicity(__i)?; } record.function_queries[405].output_at(__i).to_array::() }, _ => aiur_fn_405(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_13]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_13]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[471].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_11, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[477].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i)?; } record.function_queries[477].output_at(__i).to_array::() }, _ => aiur_fn_477(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_13]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_13]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42368,46 +43537,46 @@ fn aiur_fn_471( } }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_6, __v_10, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_471] = [__v_13]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_13]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_13]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_13]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_12]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_12]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_471] = [__v_11]; - record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_477] = [__v_11]; + record.function_queries[477].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42419,25 +43588,26 @@ fn aiur_fn_471( }) } -const INPUT_SIZE_472: usize = 4; -const IN_472: usize = 4; -const OUT_472: usize = 3; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_478: usize = 4; +const IN_478: usize = 4; +const OUT_478: usize = 3; +fn aiur_fn_478( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], ExecError> { +) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(478); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_472] = [__v_4, __v_0, __v_1]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_4, __v_0, __v_1]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -42445,46 +43615,46 @@ fn aiur_fn_472( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_472] = [__v_5, __v_0, __v_1]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_5, __v_0, __v_1]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[452].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i)?; } record.function_queries[452].output_at(__i).to_array::() }, _ => aiur_fn_452(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_6, __v_0, __v_1]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[491].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i)?; } record.function_queries[491].output_at(__i).to_array::() }, _ => aiur_fn_491(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[491].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i)?; } record.function_queries[491].output_at(__i).to_array::() }, _ => aiur_fn_491(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[474].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i); } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[480].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[480].bump_multiplicity(__i)?; } record.function_queries[480].output_at(__i).to_array::() }, _ => aiur_fn_480(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_11, __v_12, __v_13]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[484].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i)?; } record.function_queries[484].output_at(__i).to_array::() }, _ => aiur_fn_484(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_11, __v_12, __v_13]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42492,21 +43662,21 @@ fn aiur_fn_472( _ => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[479].bump_multiplicity(__i); } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[485].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i)?; } record.function_queries[485].output_at(__i).to_array::() }, _ => aiur_fn_485(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_11, __v_12, __v_13]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[486].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i)?; } record.function_queries[486].output_at(__i).to_array::() }, _ => aiur_fn_486(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_472] = [__v_11, __v_12, __v_13]; - record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_478] = [__v_11, __v_12, __v_13]; + record.function_queries[478].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42521,63 +43691,65 @@ fn aiur_fn_472( }) } -const INPUT_SIZE_473: usize = 12; -const IN_473: usize = 12; -const OUT_473: usize = 1; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_479: usize = 12; +const IN_479: usize = 12; +const OUT_479: usize = 1; +fn aiur_fn_479( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_473], ExecError> { +) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(479); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_473] = [__v_5]; - record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_479] = [__v_5]; + record.function_queries[479].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_473] = [__v_12]; - record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_479] = [__v_12]; + record.function_queries[479].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_474: usize = 6; -const IN_474: usize = 6; -const OUT_474: usize = 3; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_480: usize = 6; +const IN_480: usize = 6; +const OUT_480: usize = 3; +fn aiur_fn_480( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_474], ExecError> { +) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(480); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -42590,9 +43762,9 @@ fn aiur_fn_474( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -42605,26 +43777,26 @@ fn aiur_fn_474( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[487].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i)?; } record.function_queries[487].output_at(__i).to_array::() }, _ => aiur_fn_487(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[487].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i)?; } record.function_queries[487].output_at(__i).to_array::() }, _ => aiur_fn_487(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_474] = [__v_34, __v_2, __v_3]; - record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_480] = [__v_34, __v_2, __v_3]; + record.function_queries[480].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[482].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i)?; } record.function_queries[482].output_at(__i).to_array::() }, _ => aiur_fn_482(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_34, __v_35, __v_36]; - record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_480] = [__v_34, __v_35, __v_36]; + record.function_queries[480].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42632,49 +43804,49 @@ fn aiur_fn_474( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[475].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[481].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i)?; } record.function_queries[481].output_at(__i).to_array::() }, _ => aiur_fn_481(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_34, __v_35, __v_36]; - record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_480] = [__v_34, __v_35, __v_36]; + record.function_queries[480].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[479].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[479].bump_multiplicity(__i)?; } record.function_queries[479].output_at(__i).to_array::() }, _ => aiur_fn_479(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[479].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[479].bump_multiplicity(__i)?; } record.function_queries[479].output_at(__i).to_array::() }, _ => aiur_fn_479(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[475].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[481].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i)?; } record.function_queries[481].output_at(__i).to_array::() }, _ => aiur_fn_481(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_37, __v_38, __v_39]; - record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_480] = [__v_37, __v_38, __v_39]; + record.function_queries[480].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[482].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i)?; } record.function_queries[482].output_at(__i).to_array::() }, _ => aiur_fn_482(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_38, __v_39, __v_40]; - record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_480] = [__v_38, __v_39, __v_40]; + record.function_queries[480].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[483].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i)?; } record.function_queries[483].output_at(__i).to_array::() }, _ => aiur_fn_483(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_474] = [__v_38, __v_39, __v_40]; - record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_480] = [__v_38, __v_39, __v_40]; + record.function_queries[480].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42687,178 +43859,182 @@ fn aiur_fn_474( }) } -const INPUT_SIZE_475: usize = 4; -const IN_475: usize = 4; -const OUT_475: usize = 3; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_481: usize = 4; +const IN_481: usize = 4; +const OUT_481: usize = 3; +fn aiur_fn_481( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_475], ExecError> { +) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + record.checkpoint(481); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_6, __v_1, __v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11]; - record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_481] = [__v_9, __v_10, __v_11]; + record.function_queries[481].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_475] = [__v_6, __v_0, __v_1]; - record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_481] = [__v_6, __v_0, __v_1]; + record.function_queries[481].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_476: usize = 4; -const IN_476: usize = 4; -const OUT_476: usize = 3; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_482: usize = 4; +const IN_482: usize = 4; +const OUT_482: usize = 3; +fn aiur_fn_482( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_476], ExecError> { +) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + record.checkpoint(482); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_6, __v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; - record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_482] = [__v_9, __v_10, __v_11]; + record.function_queries[482].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_476] = [__v_6, __v_0, __v_1]; - record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_482] = [__v_6, __v_0, __v_1]; + record.function_queries[482].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_477: usize = 4; -const IN_477: usize = 4; -const OUT_477: usize = 3; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_483: usize = 4; +const IN_483: usize = 4; +const OUT_483: usize = 3; +fn aiur_fn_483( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], ExecError> { +) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + record.checkpoint(483); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_7, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 - __v_10); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_8, __v_9, __v_11, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_477] = [__v_12, __v_13, __v_14]; - record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_483] = [__v_12, __v_13, __v_14]; + record.function_queries[483].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1]; - record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_483] = [__v_8, __v_0, __v_1]; + record.function_queries[483].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1]; - record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_483] = [__v_6, __v_0, __v_1]; + record.function_queries[483].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_478: usize = 5; -const IN_478: usize = 5; -const OUT_478: usize = 3; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_484: usize = 5; +const IN_484: usize = 5; +const OUT_484: usize = 3; +fn aiur_fn_484( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_478], ExecError> { +) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; + record.checkpoint(484); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[488].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i)?; } record.function_queries[488].output_at(__i).to_array::() }, _ => aiur_fn_488(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_1, __v_6, __v_8, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_478] = [__v_9, __v_10, __v_11]; - record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_484] = [__v_9, __v_10, __v_11]; + record.function_queries[484].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -42871,35 +44047,35 @@ fn aiur_fn_478( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[487].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i)?; } record.function_queries[487].output_at(__i).to_array::() }, _ => aiur_fn_487(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_21, __v_1, __v_2]; - record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_484] = [__v_21, __v_1, __v_2]; + record.function_queries[484].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[492].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i)?; } record.function_queries[492].output_at(__i).to_array::() }, _ => aiur_fn_492(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_22, __v_2, __v_24, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_478] = [__v_25, __v_26, __v_27]; - record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_484] = [__v_25, __v_26, __v_27]; + record.function_queries[484].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_478] = [__v_23, __v_1, __v_2]; - record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_484] = [__v_23, __v_1, __v_2]; + record.function_queries[484].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42910,40 +44086,41 @@ fn aiur_fn_478( }) } -const INPUT_SIZE_479: usize = 5; -const IN_479: usize = 5; -const OUT_479: usize = 3; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_485: usize = 5; +const IN_485: usize = 5; +const OUT_485: usize = 3; +fn aiur_fn_485( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_479], ExecError> { +) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; + record.checkpoint(485); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[488].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i)?; } record.function_queries[488].output_at(__i).to_array::() }, _ => aiur_fn_488(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_6, __v_2, __v_8, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_479] = [__v_9, __v_10, __v_11]; - record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_485] = [__v_9, __v_10, __v_11]; + record.function_queries[485].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -42956,35 +44133,35 @@ fn aiur_fn_479( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[487].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i)?; } record.function_queries[487].output_at(__i).to_array::() }, _ => aiur_fn_487(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_21, __v_1, __v_2]; - record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_485] = [__v_21, __v_1, __v_2]; + record.function_queries[485].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[492].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i)?; } record.function_queries[492].output_at(__i).to_array::() }, _ => aiur_fn_492(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_1, __v_22, __v_24, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_479] = [__v_25, __v_26, __v_27]; - record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_485] = [__v_25, __v_26, __v_27]; + record.function_queries[485].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_479] = [__v_23, __v_1, __v_2]; - record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_485] = [__v_23, __v_1, __v_2]; + record.function_queries[485].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -42995,24 +44172,25 @@ fn aiur_fn_479( }) } -const INPUT_SIZE_480: usize = 4; -const IN_480: usize = 4; -const OUT_480: usize = 3; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_486: usize = 4; +const IN_486: usize = 4; +const OUT_486: usize = 3; +fn aiur_fn_486( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_480], ExecError> { +) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; + record.checkpoint(486); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[488].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i)?; } record.function_queries[488].output_at(__i).to_array::() }, _ => aiur_fn_488(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[488].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i)?; } record.function_queries[488].output_at(__i).to_array::() }, _ => aiur_fn_488(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -43021,23 +44199,23 @@ fn aiur_fn_480( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_5, __v_7, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; - record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_486] = [__v_10, __v_11, __v_12]; + record.function_queries[486].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_5, __v_1, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; - record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_486] = [__v_10, __v_11, __v_12]; + record.function_queries[486].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -43047,18 +44225,18 @@ fn aiur_fn_480( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_0, __v_7, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[478].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i)?; } record.function_queries[478].output_at(__i).to_array::() }, _ => aiur_fn_478(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_480] = [__v_10, __v_11, __v_12]; - record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_486] = [__v_10, __v_11, __v_12]; + record.function_queries[486].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_480] = [__v_8, __v_0, __v_1]; - record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_486] = [__v_8, __v_0, __v_1]; + record.function_queries[486].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -43067,149 +44245,152 @@ fn aiur_fn_480( }) } -const INPUT_SIZE_481: usize = 12; -const IN_481: usize = 12; -const OUT_481: usize = 1; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_487: usize = 12; +const IN_487: usize = 12; +const OUT_487: usize = 1; +fn aiur_fn_487( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_481], ExecError> { +) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(487); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_481] = [__v_12]; - record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_487] = [__v_12]; + record.function_queries[487].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_481] = [__v_12]; - record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_487] = [__v_12]; + record.function_queries[487].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_481] = [__v_12]; - record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_487] = [__v_12]; + record.function_queries[487].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_482: usize = 2; -const IN_482: usize = 2; -const OUT_482: usize = 2; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_488: usize = 2; +const IN_488: usize = 2; +const OUT_488: usize = 2; +fn aiur_fn_488( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_482], ExecError> { +) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(488); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(8); - let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_18, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_482] = [__v_19, __v_20]; - record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_488] = [__v_19, __v_20]; + record.function_queries[488].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_17, __v_0]; - record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_488] = [__v_17, __v_0]; + record.function_queries[488].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_482] = [__v_15, __v_8]; - record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_488] = [__v_15, __v_8]; + record.function_queries[488].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_482] = [__v_8, __v_0]; - record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_488] = [__v_8, __v_0]; + record.function_queries[488].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_483: usize = 1; -const IN_483: usize = 1; -const OUT_483: usize = 2; -fn aiur_fn_483( - inp: [G; IN_483], +const INPUT_SIZE_489: usize = 1; +const IN_489: usize = 1; +const OUT_489: usize = 2; +fn aiur_fn_489( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_483], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(489); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -43224,81 +44405,82 @@ fn aiur_fn_483( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_20, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_21, __v_22]; - record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_489] = [__v_21, __v_22]; + record.function_queries[489].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_20, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_483] = [__v_21, __v_22]; - record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_489] = [__v_21, __v_22]; + record.function_queries[489].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_20, __v_0]; - record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_489] = [__v_20, __v_0]; + record.function_queries[489].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_483] = [__v_7, __v_0]; - record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_489] = [__v_7, __v_0]; + record.function_queries[489].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_484: usize = 3; -const IN_484: usize = 3; -const OUT_484: usize = 1; -fn aiur_fn_484( - inp: [G; IN_484], +const INPUT_SIZE_490: usize = 3; +const IN_490: usize = 3; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_484], ExecError> { +) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } }; + record.checkpoint(490); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[491].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i)?; } record.function_queries[491].output_at(__i).to_array::() }, _ => aiur_fn_491(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[491].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i)?; } record.function_queries[491].output_at(__i).to_array::() }, _ => aiur_fn_491(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_7]; - record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_490] = [__v_7]; + record.function_queries[490].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_7]; - record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_490] = [__v_7]; + record.function_queries[490].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -43311,9 +44493,9 @@ fn aiur_fn_484( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_21: G = __loaded[0]; let __v_22: G = __loaded[1]; let __v_23: G = __loaded[2]; @@ -43326,27 +44508,27 @@ fn aiur_fn_484( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[492].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i)?; } record.function_queries[492].output_at(__i).to_array::() }, _ => aiur_fn_492(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[492].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i)?; } record.function_queries[492].output_at(__i).to_array::() }, _ => aiur_fn_492(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_34, __v_36, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_37]; - record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_490] = [__v_37]; + record.function_queries[490].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_34, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_37]; - record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_490] = [__v_37]; + record.function_queries[490].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -43354,16 +44536,16 @@ fn aiur_fn_484( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_36, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_484] = [__v_37]; - record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_490] = [__v_37]; + record.function_queries[490].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_484] = [__v_37]; - record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_490] = [__v_37]; + record.function_queries[490].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -43379,21 +44561,22 @@ fn aiur_fn_484( }) } -const INPUT_SIZE_485: usize = 1; -const IN_485: usize = 1; -const OUT_485: usize = 2; -fn aiur_fn_485( - inp: [G; IN_485], +const INPUT_SIZE_491: usize = 1; +const IN_491: usize = 1; +const OUT_491: usize = 2; +fn aiur_fn_491( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_485], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(491); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -43401,8 +44584,8 @@ fn aiur_fn_485( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_485] = [__v_4, __v_7]; - record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_491] = [__v_4, __v_7]; + record.function_queries[491].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -43438,228 +44621,232 @@ fn aiur_fn_485( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_485] = [__v_39, __v_40]; - record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_491] = [__v_39, __v_40]; + record.function_queries[491].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_486: usize = 14; -const IN_486: usize = 14; -const OUT_486: usize = 2; -fn aiur_fn_486( - inp: [G; IN_486], +const INPUT_SIZE_492: usize = 14; +const IN_492: usize = 14; +const OUT_492: usize = 2; +fn aiur_fn_492( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_486], ExecError> { +) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(492); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_15, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_16, __v_17]; - record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_492] = [__v_16, __v_17]; + record.function_queries[492].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_16, __v_0]; - record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_492] = [__v_16, __v_0]; + record.function_queries[492].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[489].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i)?; } record.function_queries[489].output_at(__i).to_array::() }, _ => aiur_fn_489(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_15, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[429].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i)?; } record.function_queries[429].output_at(__i).to_array::() }, _ => aiur_fn_429(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_486] = [__v_16, __v_17]; - record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_492] = [__v_16, __v_17]; + record.function_queries[492].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_16, __v_0]; - record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_492] = [__v_16, __v_0]; + record.function_queries[492].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_486] = [__v_14, __v_0]; - record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_492] = [__v_14, __v_0]; + record.function_queries[492].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_487: usize = 2; -const IN_487: usize = 2; -const OUT_487: usize = 1; -fn aiur_fn_487( - inp: [G; IN_487], +const INPUT_SIZE_493: usize = 2; +const IN_493: usize = 2; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_487], ExecError> { +) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + record.checkpoint(493); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[495].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i)?; } record.function_queries[495].output_at(__i).to_array::() }, _ => aiur_fn_495(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_6]; - record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_493] = [__v_6]; + record.function_queries[493].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[494].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i)?; } record.function_queries[494].output_at(__i).to_array::() }, _ => aiur_fn_494(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_487] = [__v_3]; - record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_493] = [__v_3]; + record.function_queries[493].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_488: usize = 3; -const IN_488: usize = 3; -const OUT_488: usize = 1; -fn aiur_fn_488( - inp: [G; IN_488], +const INPUT_SIZE_494: usize = 3; +const IN_494: usize = 3; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { +) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(494); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[356].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i)?; } record.function_queries[356].output_at(__i).to_array::() }, _ => aiur_fn_356(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[347].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i)?; } record.function_queries[347].output_at(__i).to_array::() }, _ => aiur_fn_347(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[495].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i)?; } record.function_queries[495].output_at(__i).to_array::() }, _ => aiur_fn_495(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_8]; - record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_494] = [__v_8]; + record.function_queries[494].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[355].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i)?; } record.function_queries[355].output_at(__i).to_array::() }, _ => aiur_fn_355(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[495].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i)?; } record.function_queries[495].output_at(__i).to_array::() }, _ => aiur_fn_495(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_12, __v_6, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_488] = [__v_14]; - record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_494] = [__v_14]; + record.function_queries[494].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_489: usize = 2; -const IN_489: usize = 2; -const OUT_489: usize = 1; -fn aiur_fn_489( - inp: [G; IN_489], +const INPUT_SIZE_495: usize = 2; +const IN_495: usize = 2; +const OUT_495: usize = 1; +fn aiur_fn_495( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], ExecError> { +) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(495); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_6, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_10]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_495] = [__v_10]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[335].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i)?; } record.function_queries[335].output_at(__i).to_array::() }, _ => aiur_fn_335(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_489] = [__v_12]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_495] = [__v_12]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -43672,91 +44859,91 @@ fn aiur_fn_489( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[436].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i)?; } record.function_queries[436].output_at(__i).to_array::() }, _ => aiur_fn_436(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[437].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i)?; } record.function_queries[437].output_at(__i).to_array::() }, _ => aiur_fn_437(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_21, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_22]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_495] = [__v_22]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_8, __v_7, __v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[496].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i)?; } record.function_queries[496].output_at(__i).to_array::() }, _ => aiur_fn_496(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_12]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_495] = [__v_12]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_489] = [__v_12]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_495] = [__v_12]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[334].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i)?; } record.function_queries[334].output_at(__i).to_array::() }, _ => aiur_fn_334(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_489] = [__v_13]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_495] = [__v_13]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_4, __v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[505].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i)?; } record.function_queries[505].output_at(__i).to_array::() }, _ => aiur_fn_505(__key, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_9]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_495] = [__v_9]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[491].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[497].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i)?; } record.function_queries[497].output_at(__i).to_array::() }, _ => aiur_fn_497(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_6]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_495] = [__v_6]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_3, __v_4, __v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[503].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[503].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[503].bump_multiplicity(__i)?; } record.function_queries[503].output_at(__i).to_array::() }, _ => aiur_fn_503(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_489] = [__v_6]; - record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_495] = [__v_6]; + record.function_queries[495].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -43766,53 +44953,54 @@ fn aiur_fn_489( }) } -const INPUT_SIZE_490: usize = 4; -const IN_490: usize = 4; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_490], +const INPUT_SIZE_496: usize = 4; +const IN_496: usize = 4; +const OUT_496: usize = 1; +fn aiur_fn_496( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_490], ExecError> { +) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(496); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_490] = [__v_0]; - record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_496] = [__v_0]; + record.function_queries[496].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_2, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_9]; - record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_496] = [__v_9]; + record.function_queries[496].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43820,24 +45008,24 @@ fn aiur_fn_490( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_8, __v_2, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_5, __v_12, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[505].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i)?; } record.function_queries[505].output_at(__i).to_array::() }, _ => aiur_fn_505(__key, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_9, __v_6, __v_14, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[496].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i)?; } record.function_queries[496].output_at(__i).to_array::() }, _ => aiur_fn_496(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_15]; - record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_496] = [__v_15]; + record.function_queries[496].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -43845,32 +45033,32 @@ fn aiur_fn_490( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_2, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_12, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_5, __v_15, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[505].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i)?; } record.function_queries[505].output_at(__i).to_array::() }, _ => aiur_fn_505(__key, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_16, __v_6, __v_22, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[496].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i)?; } record.function_queries[496].output_at(__i).to_array::() }, _ => aiur_fn_496(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_490] = [__v_23]; - record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_496] = [__v_23]; + record.function_queries[496].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -43887,43 +45075,44 @@ fn aiur_fn_490( }) } -const INPUT_SIZE_491: usize = 2; -const IN_491: usize = 2; -const OUT_491: usize = 1; -fn aiur_fn_491( - inp: [G; IN_491], +const INPUT_SIZE_497: usize = 2; +const IN_497: usize = 2; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], ExecError> { +) -> Result<[G; OUT_497], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(497); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[387].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i)?; } record.function_queries[387].output_at(__i).to_array::() }, _ => aiur_fn_387(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_8]; - record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_497] = [__v_8]; + record.function_queries[497].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_8]; - record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_497] = [__v_8]; + record.function_queries[497].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -43933,25 +45122,26 @@ fn aiur_fn_491( }) } -const INPUT_SIZE_492: usize = 4; -const IN_492: usize = 4; -const OUT_492: usize = 1; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_498: usize = 4; +const IN_498: usize = 4; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_492], ExecError> { +) -> Result<[G; OUT_498], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + record.checkpoint(498); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[493].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i); } let __ret: [G; OUT_493] = unsafe { *(record.function_queries[493].output_at(__i).as_ptr() as *const [G; OUT_493]) }; __ret }, _ => aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[499].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i)?; } record.function_queries[499].output_at(__i).to_array::() }, _ => aiur_fn_499(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -43960,11 +45150,11 @@ fn aiur_fn_492( 1u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_7, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_492] = [__v_13]; - record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_498] = [__v_13]; + record.function_queries[498].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -43974,31 +45164,32 @@ fn aiur_fn_492( }) } -const INPUT_SIZE_493: usize = 3; -const IN_493: usize = 3; -const OUT_493: usize = 1; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_499: usize = 3; +const IN_499: usize = 3; +const OUT_499: usize = 1; +fn aiur_fn_499( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], ExecError> { +) -> Result<[G; OUT_499], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(499); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_3]; - record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_499] = [__v_3]; + record.function_queries[499].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -44006,18 +45197,18 @@ fn aiur_fn_493( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[493].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i); } let __ret: [G; OUT_493] = unsafe { *(record.function_queries[493].output_at(__i).as_ptr() as *const [G; OUT_493]) }; __ret }, _ => aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_11, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[499].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i)?; } record.function_queries[499].output_at(__i).to_array::() }, _ => aiur_fn_499(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_493] = [__v_12]; - record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_499] = [__v_12]; + record.function_queries[499].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_493] = [__v_3]; - record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_499] = [__v_3]; + record.function_queries[499].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -44026,88 +45217,90 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 3; -const IN_494: usize = 3; -const OUT_494: usize = 0; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_500: usize = 3; +const IN_500: usize = 3; +const OUT_500: usize = 0; +fn aiur_fn_500( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], ExecError> { +) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(500); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_494] = []; - record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_500] = []; + record.function_queries[500].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) }); } - let __ret: [G; OUT_494] = []; - record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_500] = []; + record.function_queries[500].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_495: usize = 4; -const IN_495: usize = 4; -const OUT_495: usize = 0; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_501: usize = 4; +const IN_501: usize = 4; +const OUT_501: usize = 0; +fn aiur_fn_501( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], ExecError> { +) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(501); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_495] = []; - record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_501] = []; + record.function_queries[501].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_495] = []; - record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_501] = []; + record.function_queries[501].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[343].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i)?; } record.function_queries[343].output_at(__i).to_array::() }, _ => aiur_fn_343(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } - let __ret: [G; OUT_495] = []; - record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_501] = []; + record.function_queries[501].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -44116,24 +45309,25 @@ fn aiur_fn_495( }) } -const INPUT_SIZE_496: usize = 7; -const IN_496: usize = 7; -const OUT_496: usize = 1; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_502: usize = 7; +const IN_502: usize = 7; +const OUT_502: usize = 1; +fn aiur_fn_502( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], ExecError> { +) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(502); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -44143,24 +45337,24 @@ fn aiur_fn_496( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_496] = [__v_8]; - record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_8, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[500].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i)?; } record.function_queries[500].output_at(__i).to_array::() }, _ => aiur_fn_500(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_502] = [__v_8]; + record.function_queries[502].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_8, __v_9, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[501].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i)?; } record.function_queries[501].output_at(__i).to_array::() }, _ => aiur_fn_501(__key, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_9, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[502].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i)?; } record.function_queries[502].output_at(__i).to_array::() }, _ => aiur_fn_502(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_496] = [__v_18]; - record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_502] = [__v_18]; + record.function_queries[502].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -44172,37 +45366,38 @@ fn aiur_fn_496( }) } -const INPUT_SIZE_497: usize = 4; -const IN_497: usize = 4; -const OUT_497: usize = 1; -fn aiur_fn_497( - inp: [G; IN_497], +const INPUT_SIZE_503: usize = 4; +const IN_503: usize = 4; +const OUT_503: usize = 1; +fn aiur_fn_503( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_497], ExecError> { +) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + record.checkpoint(503); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -44221,9 +45416,9 @@ fn aiur_fn_497( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_20, __v_21, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_27: G = __loaded[0]; let __v_28: G = __loaded[1]; let __v_29: G = __loaded[2]; @@ -44242,18 +45437,18 @@ fn aiur_fn_497( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_29, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_29, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_40, __v_7, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[441].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i)?; } record.function_queries[441].output_at(__i).to_array::() }, _ => aiur_fn_441(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_15, __v_10, __v_42, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[498].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i)?; } record.function_queries[498].output_at(__i).to_array::() }, _ => aiur_fn_498(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[502].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i)?; } record.function_queries[502].output_at(__i).to_array::() }, _ => aiur_fn_502(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_497] = [__v_45]; - record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_503] = [__v_45]; + record.function_queries[503].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -44273,31 +45468,32 @@ fn aiur_fn_497( }) } -const INPUT_SIZE_498: usize = 2; -const IN_498: usize = 2; -const OUT_498: usize = 1; -fn aiur_fn_498( - inp: [G; IN_498], +const INPUT_SIZE_504: usize = 2; +const IN_504: usize = 2; +const OUT_504: usize = 1; +fn aiur_fn_504( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_498], ExecError> { +) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + record.checkpoint(504); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_498] = [__v_5]; - record.function_queries[498].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_504] = [__v_5]; + record.function_queries[504].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -44307,43 +45503,45 @@ fn aiur_fn_498( }) } -const INPUT_SIZE_499: usize = 3; -const IN_499: usize = 3; -const OUT_499: usize = 0; -fn aiur_fn_499( - inp: [G; IN_499], +const INPUT_SIZE_505: usize = 3; +const IN_505: usize = 3; +const OUT_505: usize = 0; +fn aiur_fn_505( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_499], ExecError> { +) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + record.checkpoint(505); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_3, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } - let __ret: [G; OUT_499] = []; - record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_505] = []; + record.function_queries[505].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_500: usize = 0; -const IN_500: usize = 0; -const OUT_500: usize = 1; -fn aiur_fn_500( - inp: [G; IN_500], +const INPUT_SIZE_506: usize = 0; +const IN_506: usize = 0; +const OUT_506: usize = 1; +fn aiur_fn_506( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_500], ExecError> { +) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(506); let __v_0: G = G::from_u64(41); let __v_1: G = G::from_u64(153); let __v_2: G = G::from_u64(128); @@ -44376,23 +45574,24 @@ fn aiur_fn_500( let __v_29: G = G::from_u64(227); let __v_30: G = G::from_u64(22); let __v_31: G = G::from_u64(236); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_500] = [__v_32]; - record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_506] = [__v_32]; + record.function_queries[506].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_501: usize = 0; -const IN_501: usize = 0; -const OUT_501: usize = 1; -fn aiur_fn_501( - inp: [G; IN_501], +const INPUT_SIZE_507: usize = 0; +const IN_507: usize = 0; +const OUT_507: usize = 1; +fn aiur_fn_507( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_501], ExecError> { +) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(507); let __v_0: G = G::from_u64(27); let __v_1: G = G::from_u64(172); let __v_2: G = G::from_u64(4); @@ -44425,23 +45624,24 @@ fn aiur_fn_501( let __v_29: G = G::from_u64(112); let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(42); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_501] = [__v_32]; - record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_507] = [__v_32]; + record.function_queries[507].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_502: usize = 0; -const IN_502: usize = 0; -const OUT_502: usize = 1; -fn aiur_fn_502( - inp: [G; IN_502], +const INPUT_SIZE_508: usize = 0; +const IN_508: usize = 0; +const OUT_508: usize = 1; +fn aiur_fn_508( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_502], ExecError> { +) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(508); let __v_0: G = G::from_u64(18); let __v_1: G = G::from_u64(243); let __v_2: G = G::from_u64(134); @@ -44474,23 +45674,24 @@ fn aiur_fn_502( let __v_29: G = G::from_u64(139); let __v_30: G = G::from_u64(105); let __v_31: G = G::from_u64(103); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_502] = [__v_32]; - record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_508] = [__v_32]; + record.function_queries[508].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_503: usize = 0; -const IN_503: usize = 0; -const OUT_503: usize = 1; -fn aiur_fn_503( - inp: [G; IN_503], +const INPUT_SIZE_509: usize = 0; +const IN_509: usize = 0; +const OUT_509: usize = 1; +fn aiur_fn_509( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_503], ExecError> { +) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(509); let __v_0: G = G::from_u64(123); let __v_1: G = G::from_u64(63); let __v_2: G = G::from_u64(106); @@ -44523,23 +45724,24 @@ fn aiur_fn_503( let __v_29: G = G::from_u64(211); let __v_30: G = G::from_u64(33); let __v_31: G = G::from_u64(76); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_503] = [__v_32]; - record.function_queries[503].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_509] = [__v_32]; + record.function_queries[509].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_504: usize = 0; -const IN_504: usize = 0; -const OUT_504: usize = 1; -fn aiur_fn_504( - inp: [G; IN_504], +const INPUT_SIZE_510: usize = 0; +const IN_510: usize = 0; +const OUT_510: usize = 1; +fn aiur_fn_510( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_504], ExecError> { +) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(510); let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(20); let __v_2: G = G::from_u64(112); @@ -44572,23 +45774,24 @@ fn aiur_fn_504( let __v_29: G = G::from_u64(141); let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(208); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_504] = [__v_32]; - record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_510] = [__v_32]; + record.function_queries[510].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_505: usize = 0; -const IN_505: usize = 0; -const OUT_505: usize = 1; -fn aiur_fn_505( - inp: [G; IN_505], +const INPUT_SIZE_511: usize = 0; +const IN_511: usize = 0; +const OUT_511: usize = 1; +fn aiur_fn_511( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_505], ExecError> { +) -> Result<[G; OUT_511], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(511); let __v_0: G = G::from_u64(35); let __v_1: G = G::from_u64(190); let __v_2: G = G::from_u64(163); @@ -44621,23 +45824,24 @@ fn aiur_fn_505( let __v_29: G = G::from_u64(166); let __v_30: G = G::from_u64(32); let __v_31: G = G::from_u64(77); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_505] = [__v_32]; - record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_511] = [__v_32]; + record.function_queries[511].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_506: usize = 0; -const IN_506: usize = 0; -const OUT_506: usize = 1; -fn aiur_fn_506( - inp: [G; IN_506], +const INPUT_SIZE_512: usize = 0; +const IN_512: usize = 0; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_506], ExecError> { +) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(512); let __v_0: G = G::from_u64(190); let __v_1: G = G::from_u64(80); let __v_2: G = G::from_u64(182); @@ -44670,23 +45874,24 @@ fn aiur_fn_506( let __v_29: G = G::from_u64(97); let __v_30: G = G::from_u64(93); let __v_31: G = G::from_u64(232); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_506] = [__v_32]; - record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_512] = [__v_32]; + record.function_queries[512].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_507: usize = 0; -const IN_507: usize = 0; -const OUT_507: usize = 1; -fn aiur_fn_507( - inp: [G; IN_507], +const INPUT_SIZE_513: usize = 0; +const IN_513: usize = 0; +const OUT_513: usize = 1; +fn aiur_fn_513( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_507], ExecError> { +) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(513); let __v_0: G = G::from_u64(196); let __v_1: G = G::from_u64(137); let __v_2: G = G::from_u64(50); @@ -44719,23 +45924,24 @@ fn aiur_fn_507( let __v_29: G = G::from_u64(147); let __v_30: G = G::from_u64(191); let __v_31: G = G::from_u64(34); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_507] = [__v_32]; - record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_513] = [__v_32]; + record.function_queries[513].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_508: usize = 0; -const IN_508: usize = 0; -const OUT_508: usize = 1; -fn aiur_fn_508( - inp: [G; IN_508], +const INPUT_SIZE_514: usize = 0; +const IN_514: usize = 0; +const OUT_514: usize = 1; +fn aiur_fn_514( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_508], ExecError> { +) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(514); let __v_0: G = G::from_u64(14); let __v_1: G = G::from_u64(181); let __v_2: G = G::from_u64(185); @@ -44768,23 +45974,24 @@ fn aiur_fn_508( let __v_29: G = G::from_u64(237); let __v_30: G = G::from_u64(41); let __v_31: G = G::from_u64(156); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_508] = [__v_32]; - record.function_queries[508].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_514] = [__v_32]; + record.function_queries[514].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_509: usize = 0; -const IN_509: usize = 0; -const OUT_509: usize = 1; -fn aiur_fn_509( - inp: [G; IN_509], +const INPUT_SIZE_515: usize = 0; +const IN_515: usize = 0; +const OUT_515: usize = 1; +fn aiur_fn_515( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_509], ExecError> { +) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(515); let __v_0: G = G::from_u64(230); let __v_1: G = G::from_u64(235); let __v_2: G = G::from_u64(163); @@ -44817,23 +46024,24 @@ fn aiur_fn_509( let __v_29: G = G::from_u64(201); let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_509] = [__v_32]; - record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_515] = [__v_32]; + record.function_queries[515].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_510: usize = 0; -const IN_510: usize = 0; -const OUT_510: usize = 1; -fn aiur_fn_510( - inp: [G; IN_510], +const INPUT_SIZE_516: usize = 0; +const IN_516: usize = 0; +const OUT_516: usize = 1; +fn aiur_fn_516( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_510], ExecError> { +) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(516); let __v_0: G = G::from_u64(227); let __v_1: G = G::from_u64(8); let __v_2: G = G::from_u64(3); @@ -44866,23 +46074,24 @@ fn aiur_fn_510( let __v_29: G = G::from_u64(31); let __v_30: G = G::from_u64(103); let __v_31: G = G::from_u64(230); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_510] = [__v_32]; - record.function_queries[510].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_516] = [__v_32]; + record.function_queries[516].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_511: usize = 0; -const IN_511: usize = 0; -const OUT_511: usize = 1; -fn aiur_fn_511( - inp: [G; IN_511], +const INPUT_SIZE_517: usize = 0; +const IN_517: usize = 0; +const OUT_517: usize = 1; +fn aiur_fn_517( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_511], ExecError> { +) -> Result<[G; OUT_517], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(517); let __v_0: G = G::from_u64(122); let __v_1: G = G::from_u64(6); let __v_2: G = G::from_u64(73); @@ -44915,23 +46124,24 @@ fn aiur_fn_511( let __v_29: G = G::from_u64(188); let __v_30: G = G::from_u64(29); let __v_31: G = G::from_u64(23); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_511] = [__v_32]; - record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_517] = [__v_32]; + record.function_queries[517].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_512: usize = 0; -const IN_512: usize = 0; -const OUT_512: usize = 1; -fn aiur_fn_512( - inp: [G; IN_512], +const INPUT_SIZE_518: usize = 0; +const IN_518: usize = 0; +const OUT_518: usize = 1; +fn aiur_fn_518( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_512], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(518); let __v_0: G = G::from_u64(20); let __v_1: G = G::from_u64(236); let __v_2: G = G::from_u64(206); @@ -44964,23 +46174,24 @@ fn aiur_fn_512( let __v_29: G = G::from_u64(125); let __v_30: G = G::from_u64(181); let __v_31: G = G::from_u64(180); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_512] = [__v_32]; - record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_518] = [__v_32]; + record.function_queries[518].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_513: usize = 0; -const IN_513: usize = 0; -const OUT_513: usize = 1; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_519: usize = 0; +const IN_519: usize = 0; +const OUT_519: usize = 1; +fn aiur_fn_519( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { +) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(519); let __v_0: G = G::from_u64(173); let __v_1: G = G::from_u64(50); let __v_2: G = G::from_u64(192); @@ -45013,99 +46224,100 @@ fn aiur_fn_513( let __v_29: G = G::from_u64(103); let __v_30: G = G::from_u64(201); let __v_31: G = G::from_u64(250); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_513] = [__v_32]; - record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_519] = [__v_32]; + record.function_queries[519].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_514: usize = 1; -const IN_514: usize = 1; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_520: usize = 1; +const IN_520: usize = 1; +const OUT_520: usize = 1; +fn aiur_fn_520( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_514], ExecError> { +) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } }; + record.checkpoint(520); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[506].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i)?; } record.function_queries[506].output_at(__i).to_array::() }, _ => aiur_fn_506(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_3]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_3]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[507].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[507].bump_multiplicity(__i)?; } record.function_queries[507].output_at(__i).to_array::() }, _ => aiur_fn_507(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_5]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_5]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[508].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[508].bump_multiplicity(__i)?; } record.function_queries[508].output_at(__i).to_array::() }, _ => aiur_fn_508(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_7]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_7]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[518].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[518].bump_multiplicity(__i)?; } record.function_queries[518].output_at(__i).to_array::() }, _ => aiur_fn_518(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_9]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_9]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[517].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i)?; } record.function_queries[517].output_at(__i).to_array::() }, _ => aiur_fn_517(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_11]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_11]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[519].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i)?; } record.function_queries[519].output_at(__i).to_array::() }, _ => aiur_fn_519(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_13]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_13]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_514] = [__v_13]; - record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_520] = [__v_13]; + record.function_queries[520].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45122,56 +46334,57 @@ fn aiur_fn_514( }) } -const INPUT_SIZE_515: usize = 1; -const IN_515: usize = 1; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_521: usize = 1; +const IN_521: usize = 1; +const OUT_521: usize = 1; +fn aiur_fn_521( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_515], ExecError> { +) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } }; + record.checkpoint(521); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[518].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[518].bump_multiplicity(__i)?; } record.function_queries[518].output_at(__i).to_array::() }, _ => aiur_fn_518(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_3]; - record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_521] = [__v_3]; + record.function_queries[521].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[517].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i)?; } record.function_queries[517].output_at(__i).to_array::() }, _ => aiur_fn_517(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_5]; - record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_521] = [__v_5]; + record.function_queries[521].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[519].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i)?; } record.function_queries[519].output_at(__i).to_array::() }, _ => aiur_fn_519(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_515] = [__v_7]; - record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_521] = [__v_7]; + record.function_queries[521].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_515] = [__v_7]; - record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_521] = [__v_7]; + record.function_queries[521].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45182,38 +46395,39 @@ fn aiur_fn_515( }) } -const INPUT_SIZE_516: usize = 1; -const IN_516: usize = 1; -const OUT_516: usize = 3; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_522: usize = 1; +const IN_522: usize = 1; +const OUT_522: usize = 3; +fn aiur_fn_522( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], ExecError> { +) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(522); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = (__v_10 + __v_12); match __v_13.as_canonical_u64() { @@ -45222,13 +46436,13 @@ fn aiur_fn_516( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_14, __v_15, __v_18]; - record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_522] = [__v_14, __v_15, __v_18]; + record.function_queries[522].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -45238,8 +46452,8 @@ fn aiur_fn_516( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_516] = [__v_18, __v_12, __v_16]; - record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_522] = [__v_18, __v_12, __v_16]; + record.function_queries[522].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -45247,9 +46461,9 @@ fn aiur_fn_516( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_18, __v_19, __v_22]; - record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_522] = [__v_18, __v_19, __v_22]; + record.function_queries[522].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45259,9 +46473,9 @@ fn aiur_fn_516( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_18, __v_19, __v_22]; - record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_522] = [__v_18, __v_19, __v_22]; + record.function_queries[522].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45273,9 +46487,9 @@ fn aiur_fn_516( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_9, __v_10, __v_13]; - record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_522] = [__v_9, __v_10, __v_13]; + record.function_queries[522].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45285,35 +46499,36 @@ fn aiur_fn_516( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_516] = [__v_5, __v_6, __v_9]; - record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 10] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_522] = [__v_5, __v_6, __v_9]; + record.function_queries[522].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_517: usize = 2; -const IN_517: usize = 2; -const OUT_517: usize = 1; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_523: usize = 2; +const IN_523: usize = 2; +const OUT_523: usize = 1; +fn aiur_fn_523( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_517], ExecError> { +) -> Result<[G; OUT_523], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(523); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -45323,65 +46538,66 @@ fn aiur_fn_517( let __v_3: G = G::from_u64(2); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_3, __v_2, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_9: G = G::from_u64(7); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_1, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_517] = [__v_15]; - record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_523] = [__v_15]; + record.function_queries[523].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_518: usize = 4; -const IN_518: usize = 4; -const OUT_518: usize = 2; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_524: usize = 4; +const IN_524: usize = 4; +const OUT_524: usize = 2; +fn aiur_fn_524( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_518], ExecError> { +) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __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_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(524); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); - let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_6.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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_7, __v_11]; - record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_524] = [__v_7, __v_11]; + record.function_queries[524].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[522].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i)?; } record.function_queries[522].output_at(__i).to_array::() }, _ => aiur_fn_522(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[522].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i)?; } record.function_queries[522].output_at(__i).to_array::() }, _ => aiur_fn_522(__key, 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]; @@ -45391,27 +46607,27 @@ fn aiur_fn_518( let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_518] = [__v_17, __v_21]; - record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_524] = [__v_17, __v_21]; + record.function_queries[524].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[519].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { *(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519]) }; __ret }, _ => aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[525].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[525].bump_multiplicity(__i)?; } record.function_queries[525].output_at(__i).to_array::() }, _ => aiur_fn_525(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_518] = [__v_17, __v_18]; - record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_524] = [__v_17, __v_18]; + record.function_queries[524].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[519].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { *(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519]) }; __ret }, _ => aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[525].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[525].bump_multiplicity(__i)?; } record.function_queries[525].output_at(__i).to_array::() }, _ => aiur_fn_525(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_518] = [__v_14, __v_15]; - record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_524] = [__v_14, __v_15]; + record.function_queries[524].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45420,59 +46636,60 @@ fn aiur_fn_518( }) } -const INPUT_SIZE_519: usize = 6; -const IN_519: usize = 6; -const OUT_519: usize = 2; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_525: usize = 6; +const IN_525: usize = 6; +const OUT_525: usize = 2; +fn aiur_fn_525( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_519], ExecError> { +) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(525); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[522].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i)?; } record.function_queries[522].output_at(__i).to_array::() }, _ => aiur_fn_522(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[522].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i)?; } record.function_queries[522].output_at(__i).to_array::() }, _ => aiur_fn_522(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[517].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { *(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517]) }; __ret }, _ => aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[523].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[523].bump_multiplicity(__i)?; } record.function_queries[523].output_at(__i).to_array::() }, _ => aiur_fn_523(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[517].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { *(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517]) }; __ret }, _ => aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[523].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[523].bump_multiplicity(__i)?; } record.function_queries[523].output_at(__i).to_array::() }, _ => aiur_fn_523(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_14, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_22: G = G::from_u64(3); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_24, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_24, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_519] = [__v_27, __v_28]; - record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_525] = [__v_27, __v_28]; + record.function_queries[525].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -45480,9 +46697,9 @@ fn aiur_fn_519( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_14, __v_18]; - record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_525] = [__v_14, __v_18]; + record.function_queries[525].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45492,84 +46709,85 @@ fn aiur_fn_519( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_519] = [__v_11, __v_15]; - record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_525] = [__v_11, __v_15]; + record.function_queries[525].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_520: usize = 4; -const IN_520: usize = 4; -const OUT_520: usize = 2; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_526: usize = 4; +const IN_526: usize = 4; +const OUT_526: usize = 2; +fn aiur_fn_526( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], ExecError> { +) -> Result<[G; OUT_526], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __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_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(526); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); - let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_6.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 = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_520] = [__v_7, __v_11]; - record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_526] = [__v_7, __v_11]; + record.function_queries[526].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[521].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[521].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[521].bump_multiplicity(__i)?; } record.function_queries[521].output_at(__i).to_array::() }, _ => aiur_fn_521(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[518].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { *(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518]) }; __ret }, _ => aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[524].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[524].bump_multiplicity(__i)?; } record.function_queries[524].output_at(__i).to_array::() }, _ => aiur_fn_524(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_8, __v_9]; - record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_526] = [__v_8, __v_9]; + record.function_queries[526].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[506].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i)?; } record.function_queries[506].output_at(__i).to_array::() }, _ => aiur_fn_506(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[507].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[507].bump_multiplicity(__i)?; } record.function_queries[507].output_at(__i).to_array::() }, _ => aiur_fn_507(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[508].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[508].bump_multiplicity(__i)?; } record.function_queries[508].output_at(__i).to_array::() }, _ => aiur_fn_508(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[521].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[521].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { *(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521]) }; __ret }, _ => aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[527].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i)?; } record.function_queries[527].output_at(__i).to_array::() }, _ => aiur_fn_527(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_14, __v_15]; - record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_526] = [__v_14, __v_15]; + record.function_queries[526].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[522].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { *(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522]) }; __ret }, _ => aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[528].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i)?; } record.function_queries[528].output_at(__i).to_array::() }, _ => aiur_fn_528(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_14, __v_15]; - record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_526] = [__v_14, __v_15]; + record.function_queries[526].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45580,28 +46798,29 @@ fn aiur_fn_520( }) } -const INPUT_SIZE_521: usize = 3; -const IN_521: usize = 3; -const OUT_521: usize = 2; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_527: usize = 3; +const IN_527: usize = 3; +const OUT_527: usize = 2; +fn aiur_fn_527( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_527], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(527); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -45610,35 +46829,35 @@ fn aiur_fn_521( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_521] = [__v_10, __v_14]; - record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_527] = [__v_10, __v_14]; + record.function_queries[527].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = []; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[506].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i)?; } record.function_queries[506].output_at(__i).to_array::() }, _ => aiur_fn_506(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_16, __v_15, __v_11, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_1, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_21, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_521] = [__v_24, __v_25]; - record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_527] = [__v_24, __v_25]; + record.function_queries[527].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -45648,33 +46867,34 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 6; -const IN_522: usize = 6; -const OUT_522: usize = 2; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_528: usize = 6; +const IN_528: usize = 6; +const OUT_528: usize = 2; +fn aiur_fn_528( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], ExecError> { +) -> Result<[G; OUT_528], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(528); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_9, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -45683,13 +46903,13 @@ fn aiur_fn_522( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_14, __v_18]; - record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_528] = [__v_14, __v_18]; + record.function_queries[528].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -45698,31 +46918,31 @@ fn aiur_fn_522( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_522] = [__v_16, __v_20]; - record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained); + let __v_20: G = { let __values: [G; 4] = [__v_17, __v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_528] = [__v_16, __v_20]; + record.function_queries[528].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_13, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[340].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i)?; } record.function_queries[340].output_at(__i).to_array::() }, _ => aiur_fn_340(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[523].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { *(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523]) }; __ret }, _ => aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[529].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i)?; } record.function_queries[529].output_at(__i).to_array::() }, _ => aiur_fn_529(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_522] = [__v_17, __v_18]; - record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_528] = [__v_17, __v_18]; + record.function_queries[528].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -45737,25 +46957,26 @@ fn aiur_fn_522( }) } -const INPUT_SIZE_523: usize = 9; -const IN_523: usize = 9; -const OUT_523: usize = 2; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_529: usize = 9; +const IN_529: usize = 9; +const OUT_529: usize = 2; +fn aiur_fn_529( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], ExecError> { +) -> Result<[G; OUT_529], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(529); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_9 - __v_2); let __v_11: G = (__v_0 * __v_10); @@ -45765,44 +46986,44 @@ fn aiur_fn_523( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_523] = [__v_12, __v_16]; - record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_529] = [__v_12, __v_16]; + record.function_queries[529].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_12, __v_15, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[516].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i)?; } record.function_queries[516].output_at(__i).to_array::() }, _ => aiur_fn_516(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[515].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i)?; } record.function_queries[515].output_at(__i).to_array::() }, _ => aiur_fn_515(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, _ => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[179].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i)?; } record.function_queries[179].output_at(__i).to_array::() }, _ => aiur_fn_179(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, @@ -45812,25 +47033,25 @@ fn aiur_fn_523( let __v_35: G = G::from_u64(2); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 4] = [__v_35, __v_34, __v_38, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_26, __v_33, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_43, __v_40, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[511].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i)?; } record.function_queries[511].output_at(__i).to_array::() }, _ => aiur_fn_511(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; let __hit = record.function_queries[506].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[512].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i)?; } record.function_queries[512].output_at(__i).to_array::() }, _ => aiur_fn_512(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45839,12 +47060,12 @@ fn aiur_fn_523( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; let __hit = record.function_queries[507].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[507].bump_multiplicity(__i); } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[513].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[513].bump_multiplicity(__i)?; } record.function_queries[513].output_at(__i).to_array::() }, _ => aiur_fn_513(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; let __hit = record.function_queries[508].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[508].bump_multiplicity(__i); } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[514].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i)?; } record.function_queries[514].output_at(__i).to_array::() }, _ => aiur_fn_514(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -45856,65 +47077,66 @@ fn aiur_fn_523( let __v_48: G = G::from_u64(2); let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 4] = [__v_48, __v_47, __v_51, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_54: G = G::from_u64(3); let __v_55: G = G::from_u64(0); - let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_3, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_57: G = G::from_u64(3); let __v_58: G = G::from_u64(0); - let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_56, __v_4, __v_58]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[526].bump_multiplicity(__i); } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[532].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i)?; } record.function_queries[532].output_at(__i).to_array::() }, _ => aiur_fn_532(__key, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_63, __v_64]; - record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_529] = [__v_63, __v_64]; + record.function_queries[529].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_524: usize = 3; -const IN_524: usize = 3; -const OUT_524: usize = 2; -fn aiur_fn_524( - inp: [G; IN_524], +const INPUT_SIZE_530: usize = 3; +const IN_530: usize = 3; +const OUT_530: usize = 2; +fn aiur_fn_530( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_524], ExecError> { +) -> Result<[G; OUT_530], ExecError> { stacker::maybe_grow(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_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(530); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); - let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_6, __v_10]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_530] = [__v_6, __v_10]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -45923,7 +47145,7 @@ fn aiur_fn_524( 7u64 => { match __v_11.as_canonical_u64() { 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -45932,7 +47154,7 @@ fn aiur_fn_524( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_12, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[341].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i)?; } record.function_queries[341].output_at(__i).to_array::() }, _ => aiur_fn_341(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -45940,17 +47162,17 @@ fn aiur_fn_524( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_19, __v_23]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_530] = [__v_19, __v_23]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[525].bump_multiplicity(__i); } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_12, __v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[531].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i)?; } record.function_queries[531].output_at(__i).to_array::() }, _ => aiur_fn_531(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_524] = [__v_19, __v_20]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_530] = [__v_19, __v_20]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45960,9 +47182,9 @@ fn aiur_fn_524( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_18, __v_22]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_530] = [__v_18, __v_22]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45972,9 +47194,9 @@ fn aiur_fn_524( let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_18, __v_22]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_530] = [__v_18, __v_22]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45984,9 +47206,9 @@ fn aiur_fn_524( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_14, __v_18]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_530] = [__v_14, __v_18]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -45996,9 +47218,9 @@ fn aiur_fn_524( let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_524] = [__v_14, __v_18]; - record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_530] = [__v_14, __v_18]; + record.function_queries[530].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -46007,143 +47229,145 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 4; -const IN_525: usize = 4; -const OUT_525: usize = 2; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_531: usize = 4; +const IN_531: usize = 4; +const OUT_531: usize = 2; +fn aiur_fn_531( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], ExecError> { +) -> Result<[G; OUT_531], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(531); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_4, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[516].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i)?; } record.function_queries[516].output_at(__i).to_array::() }, _ => aiur_fn_516(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_24: G = G::from_u64(0); - let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 4] = [__v_19, __v_20, __v_23, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); - let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_0, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_30, __v_18, __v_25, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_33: G = G::from_u64(3); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_29, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_36: G = G::from_u64(2); let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); - let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_41, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_44, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_45, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_45, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); - let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_51.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_525] = [__v_52, __v_56]; - record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained); + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_531] = [__v_52, __v_56]; + record.function_queries[531].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_48, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_48, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; let __hit = record.function_queries[503].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[503].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[503].bump_multiplicity(__i); } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[509].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i)?; } record.function_queries[509].output_at(__i).to_array::() }, _ => aiur_fn_509(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_59: G = G::from_u64(0); - let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = { let __values: [G; 4] = [__v_54, __v_55, __v_58, __v_59]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_61: G = G::from_u64(3); let __v_62: G = G::from_u64(0); - let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 4] = [__v_61, __v_60, __v_53, __v_62]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_64: G = G::from_u64(3); let __v_65: G = G::from_u64(0); - let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_66, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_66, __v_68]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_525] = [__v_69, __v_70]; - record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_531] = [__v_69, __v_70]; + record.function_queries[531].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_526: usize = 6; -const IN_526: usize = 6; -const OUT_526: usize = 2; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_532: usize = 6; +const IN_532: usize = 6; +const OUT_532: usize = 2; +fn aiur_fn_532( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], ExecError> { +) -> Result<[G; OUT_532], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(532); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; let __hit = record.function_queries[503].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[503].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[503].bump_multiplicity(__i); } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[509].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i)?; } record.function_queries[509].output_at(__i).to_array::() }, _ => aiur_fn_509(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[510].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i)?; } record.function_queries[510].output_at(__i).to_array::() }, _ => aiur_fn_510(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -46152,97 +47376,98 @@ fn aiur_fn_526( let __v_6: G = __mc_out___mc_0[0]; let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_12, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[493].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i)?; } record.function_queries[493].output_at(__i).to_array::() }, _ => aiur_fn_493(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_13, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); - let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_19.as_canonical_u64() { 1u64 => { 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 = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_526] = [__v_20, __v_24]; - record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_532] = [__v_20, __v_24]; + record.function_queries[532].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_16, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_16, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_26: G = G::from_u64(0); - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_28: G = G::from_u64(3); let __v_29: G = G::from_u64(0); - let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_21, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_4, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_33, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_33, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_526] = [__v_36, __v_37]; - record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_532] = [__v_36, __v_37]; + record.function_queries[532].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_527: usize = 2; -const IN_527: usize = 2; -const OUT_527: usize = 1; -fn aiur_fn_527( - inp: [G; IN_527], +const INPUT_SIZE_533: usize = 2; +const IN_533: usize = 2; +const OUT_533: usize = 1; +fn aiur_fn_533( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], ExecError> { +) -> Result<[G; OUT_533], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(533); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_527] = [__v_3]; - record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_533] = [__v_3]; + record.function_queries[533].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_527] = [__v_4]; - record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_533] = [__v_4]; + record.function_queries[533].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_527] = [__v_4]; - record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_533] = [__v_4]; + record.function_queries[533].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -46254,148 +47479,155 @@ fn aiur_fn_527( }) } -const INPUT_SIZE_528: usize = 2; -const IN_528: usize = 2; -const OUT_528: usize = 1; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_534: usize = 2; +const IN_534: usize = 2; +const OUT_534: usize = 1; +fn aiur_fn_534( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_528], ExecError> { +) -> Result<[G; OUT_534], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(534); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_528] = [__v_1]; - record.function_queries[528].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_534] = [__v_1]; + record.function_queries[534].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_528] = [__v_0]; - record.function_queries[528].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_534] = [__v_0]; + record.function_queries[534].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_529: usize = 0; -const IN_529: usize = 0; -const OUT_529: usize = 2; -fn aiur_fn_529( - inp: [G; IN_529], +const INPUT_SIZE_535: usize = 0; +const IN_535: usize = 0; +const OUT_535: usize = 2; +fn aiur_fn_535( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_529], ExecError> { +) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(535); let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_529] = [__v_0, __v_1]; - record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_535] = [__v_0, __v_1]; + record.function_queries[535].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_530: usize = 0; -const IN_530: usize = 0; -const OUT_530: usize = 2; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_536: usize = 0; +const IN_536: usize = 0; +const OUT_536: usize = 2; +fn aiur_fn_536( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_530], ExecError> { +) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(536); let __v_0: G = G::from_u64(1); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_530] = [__v_0, __v_1]; - record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_536] = [__v_0, __v_1]; + record.function_queries[536].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_531: usize = 0; -const IN_531: usize = 0; -const OUT_531: usize = 2; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_537: usize = 0; +const IN_537: usize = 0; +const OUT_537: usize = 2; +fn aiur_fn_537( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_531], ExecError> { +) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(537); let __v_0: G = G::from_u64(2); let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_531] = [__v_0, __v_1]; - record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_537] = [__v_0, __v_1]; + record.function_queries[537].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_532: usize = 4; -const IN_532: usize = 4; -const OUT_532: usize = 2; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_538: usize = 4; +const IN_538: usize = 4; +const OUT_538: usize = 2; +fn aiur_fn_538( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_532], ExecError> { +) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(538); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_532] = [__v_2, __v_4]; - record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_538] = [__v_2, __v_4]; + record.function_queries[538].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_532] = [__v_0, __v_1]; - record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_538] = [__v_0, __v_1]; + record.function_queries[538].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_533: usize = 1; -const IN_533: usize = 1; -const OUT_533: usize = 2; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_539: usize = 1; +const IN_539: usize = 1; +const OUT_539: usize = 2; +fn aiur_fn_539( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], ExecError> { +) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(539); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_533] = [__v_0, __v_1]; - record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_539] = [__v_0, __v_1]; + record.function_queries[539].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_534: usize = 2; -const IN_534: usize = 2; -const OUT_534: usize = 1; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_540: usize = 2; +const IN_540: usize = 2; +const OUT_540: usize = 1; +fn aiur_fn_540( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_534], ExecError> { +) -> Result<[G; OUT_540], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(540); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -46428,7 +47660,7 @@ fn aiur_fn_534( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -46461,60 +47693,61 @@ fn aiur_fn_534( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[541].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i)?; } record.function_queries[541].output_at(__i).to_array::() }, _ => aiur_fn_541(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_72, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_72, __v_73]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_71, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_71, __v_74]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_70, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_70, __v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_69, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_69, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_68, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_68, __v_77]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_67, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_67, __v_78]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_66, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_66, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_534] = [__v_80]; - record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_540] = [__v_80]; + record.function_queries[540].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_535: usize = 8; -const IN_535: usize = 8; -const OUT_535: usize = 1; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_541: usize = 8; +const IN_541: usize = 8; +const OUT_541: usize = 1; +fn aiur_fn_541( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_535], ExecError> { +) -> Result<[G; OUT_541], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(541); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(16777216); let __v_9: G = (__v_0 * __v_8); let __v_10: G = G::from_u64(65536); @@ -46533,27 +47766,28 @@ fn aiur_fn_535( let __v_23: G = (__v_22 + __v_7); let __v_24: G = (__v_20 + __v_23); let __v_25: G = (__v_18 + __v_24); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_16, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_16, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_535] = [__v_26]; - record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_541] = [__v_26]; + record.function_queries[541].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_536: usize = 2; -const IN_536: usize = 2; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +const INPUT_SIZE_542: usize = 2; +const IN_542: usize = 2; +const OUT_542: usize = 1; +fn aiur_fn_542( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_536], ExecError> { +) -> Result<[G; OUT_542], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(542); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -46561,26 +47795,26 @@ fn aiur_fn_536( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_536] = [__v_6]; - record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_542] = [__v_6]; + record.function_queries[542].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_536] = [__v_8]; - record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_542] = [__v_8]; + record.function_queries[542].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[542].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i)?; } record.function_queries[542].output_at(__i).to_array::() }, _ => aiur_fn_542(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_7]; - record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_542] = [__v_7]; + record.function_queries[542].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -46592,54 +47826,55 @@ fn aiur_fn_536( }) } -const INPUT_SIZE_537: usize = 3; -const IN_537: usize = 3; -const OUT_537: usize = 2; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_543: usize = 3; +const IN_543: usize = 3; +const OUT_543: usize = 2; +fn aiur_fn_543( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_537], ExecError> { +) -> Result<[G; OUT_543], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + record.checkpoint(543); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_4, __v_5]; - record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_543] = [__v_4, __v_5]; + record.function_queries[543].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[542].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i)?; } record.function_queries[542].output_at(__i).to_array::() }, _ => aiur_fn_542(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[542].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i)?; } record.function_queries[542].output_at(__i).to_array::() }, _ => aiur_fn_542(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[534].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i); } let __ret: [G; OUT_534] = unsafe { *(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534]) }; __ret }, _ => aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[540].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i)?; } record.function_queries[540].output_at(__i).to_array::() }, _ => aiur_fn_540(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_7, __v_8]; - record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_543] = [__v_7, __v_8]; + record.function_queries[543].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_6, __v_7]; - record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_543] = [__v_6, __v_7]; + record.function_queries[543].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -46647,19 +47882,19 @@ fn aiur_fn_537( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_537] = [__v_6, __v_7]; - record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_543] = [__v_6, __v_7]; + record.function_queries[543].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_537] = [__v_6, __v_7]; - record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_543] = [__v_6, __v_7]; + record.function_queries[543].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -46670,146 +47905,147 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 2; -const IN_538: usize = 2; -const OUT_538: usize = 1; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_544: usize = 2; +const IN_544: usize = 2; +const OUT_544: usize = 1; +fn aiur_fn_544( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_538], ExecError> { +) -> Result<[G; OUT_544], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(544); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_10]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_10]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_10]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_10]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -46818,22 +48054,22 @@ fn aiur_fn_538( } }, 4u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_538] = [__v_8]; - record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_544] = [__v_8]; + record.function_queries[544].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -46845,64 +48081,65 @@ fn aiur_fn_538( }) } -const INPUT_SIZE_539: usize = 2; -const IN_539: usize = 2; -const OUT_539: usize = 1; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_545: usize = 2; +const IN_545: usize = 2; +const OUT_545: usize = 1; +fn aiur_fn_545( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], ExecError> { +) -> Result<[G; OUT_545], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(545); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_539] = [__v_8]; - record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_545] = [__v_8]; + record.function_queries[545].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_539] = [__v_8]; - record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_545] = [__v_8]; + record.function_queries[545].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_539] = [__v_8]; - record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_545] = [__v_8]; + record.function_queries[545].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[545].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i)?; } record.function_queries[545].output_at(__i).to_array::() }, _ => aiur_fn_545(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_10]; - record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_545] = [__v_10]; + record.function_queries[545].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -46917,34 +48154,35 @@ fn aiur_fn_539( }) } -const INPUT_SIZE_540: usize = 4; -const IN_540: usize = 4; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_546: usize = 4; +const IN_546: usize = 4; +const OUT_546: usize = 1; +fn aiur_fn_546( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], ExecError> { +) -> Result<[G; OUT_546], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(546); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_0.as_canonical_u64() { 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[547].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i)?; } record.function_queries[547].output_at(__i).to_array::() }, _ => aiur_fn_547(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_4]; - record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_546] = [__v_4]; + record.function_queries[546].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_540] = [__v_4]; - record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_546] = [__v_4]; + record.function_queries[546].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -46956,15 +48194,15 @@ fn aiur_fn_540( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_540] = [__v_4]; - record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_546] = [__v_4]; + record.function_queries[546].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[550].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i)?; } record.function_queries[550].output_at(__i).to_array::() }, _ => aiur_fn_550(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_4]; - record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_546] = [__v_4]; + record.function_queries[546].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -46979,58 +48217,60 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 2; -const IN_541: usize = 2; -const OUT_541: usize = 1; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_547: usize = 2; +const IN_547: usize = 2; +const OUT_547: usize = 1; +fn aiur_fn_547( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_541], ExecError> { +) -> Result<[G; OUT_547], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + record.checkpoint(547); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[773].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i)?; } record.function_queries[773].output_at(__i).to_array::() }, _ => aiur_fn_773(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[773].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i)?; } record.function_queries[773].output_at(__i).to_array::() }, _ => aiur_fn_773(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[548].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i)?; } record.function_queries[548].output_at(__i).to_array::() }, _ => aiur_fn_548(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_541] = [__v_7]; - record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_547] = [__v_7]; + record.function_queries[547].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_541] = [__v_6]; - record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_547] = [__v_6]; + record.function_queries[547].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_542: usize = 2; -const IN_542: usize = 2; -const OUT_542: usize = 1; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_548: usize = 2; +const IN_548: usize = 2; +const OUT_548: usize = 1; +fn aiur_fn_548( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_542], ExecError> { +) -> Result<[G; OUT_548], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(548); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -47044,12 +48284,12 @@ fn aiur_fn_542( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_542] = [__v_12]; - record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_548] = [__v_12]; + record.function_queries[548].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -47062,14 +48302,14 @@ fn aiur_fn_542( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[548].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i)?; } record.function_queries[548].output_at(__i).to_array::() }, _ => aiur_fn_548(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[549].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i)?; } record.function_queries[549].output_at(__i).to_array::() }, _ => aiur_fn_549(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_542] = [__v_24]; - record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_548] = [__v_24]; + record.function_queries[548].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -47084,126 +48324,128 @@ fn aiur_fn_542( }) } -const INPUT_SIZE_543: usize = 16; -const IN_543: usize = 16; -const OUT_543: usize = 1; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_549: usize = 16; +const IN_549: usize = 16; +const OUT_549: usize = 1; +fn aiur_fn_549( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], ExecError> { +) -> Result<[G; OUT_549], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + record.checkpoint(549); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_7, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_21, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_19, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_19, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_18, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_18, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_17, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_16, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_16, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_543] = [__v_30]; - record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_549] = [__v_30]; + record.function_queries[549].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_544: usize = 2; -const IN_544: usize = 2; -const OUT_544: usize = 1; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_550: usize = 2; +const IN_550: usize = 2; +const OUT_550: usize = 1; +fn aiur_fn_550( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_544], ExecError> { +) -> Result<[G; OUT_550], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(550); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_544] = [__v_8]; - record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_550] = [__v_8]; + record.function_queries[550].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_544] = [__v_8]; - record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_550] = [__v_8]; + record.function_queries[550].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_544] = [__v_8]; - record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_550] = [__v_8]; + record.function_queries[550].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[550].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i)?; } record.function_queries[550].output_at(__i).to_array::() }, _ => aiur_fn_550(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[534].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i)?; } record.function_queries[534].output_at(__i).to_array::() }, _ => aiur_fn_534(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_544] = [__v_10]; - record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_550] = [__v_10]; + record.function_queries[550].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -47218,89 +48460,91 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 3; -const IN_545: usize = 3; -const OUT_545: usize = 2; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_551: usize = 3; +const IN_551: usize = 3; +const OUT_551: usize = 2; +fn aiur_fn_551( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_545], ExecError> { +) -> Result<[G; OUT_551], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(551); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_4, __v_5]; - record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_551] = [__v_4, __v_5]; + record.function_queries[551].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[552].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i)?; } record.function_queries[552].output_at(__i).to_array::() }, _ => aiur_fn_552(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_545] = [__v_12, __v_13]; - record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_551] = [__v_12, __v_13]; + record.function_queries[551].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_546: usize = 9; -const IN_546: usize = 9; -const OUT_546: usize = 2; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_552: usize = 9; +const IN_552: usize = 9; +const OUT_552: usize = 2; +fn aiur_fn_552( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_546], ExecError> { +) -> Result<[G; OUT_552], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(552); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; match __v_0.as_canonical_u64() { 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_10, __v_11]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_10, __v_11]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47308,29 +48552,29 @@ fn aiur_fn_546( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[544].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i)?; } record.function_queries[544].output_at(__i).to_array::() }, _ => aiur_fn_544(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_10, __v_11]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_10, __v_11]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47338,43 +48582,43 @@ fn aiur_fn_546( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[545].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i)?; } record.function_queries[545].output_at(__i).to_array::() }, _ => aiur_fn_545(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[537].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i); } let __ret: [G; OUT_537] = unsafe { *(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537]) }; __ret }, _ => aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[543].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i)?; } record.function_queries[543].output_at(__i).to_array::() }, _ => aiur_fn_543(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_14, __v_15]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_14, __v_15]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47382,49 +48626,49 @@ fn aiur_fn_546( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_13, __v_14]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_13, __v_14]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47432,57 +48676,57 @@ fn aiur_fn_546( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_13, __v_14]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_13, __v_14]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47490,65 +48734,65 @@ fn aiur_fn_546( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_13, __v_14]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_13, __v_14]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47556,79 +48800,79 @@ fn aiur_fn_546( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_11, __v_12, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_9, __v_10, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_17, __v_18]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_17, __v_18]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47636,29 +48880,29 @@ fn aiur_fn_546( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_2, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[546].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i)?; } record.function_queries[546].output_at(__i).to_array::() }, _ => aiur_fn_546(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_10, __v_11]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_10, __v_11]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47666,33 +48910,33 @@ fn aiur_fn_546( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[537].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i); } let __ret: [G; OUT_537] = unsafe { *(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537]) }; __ret }, _ => aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[543].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i)?; } record.function_queries[543].output_at(__i).to_array::() }, _ => aiur_fn_543(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_9, __v_10, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_18, __v_19]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_18, __v_19]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_546] = [__v_9, __v_10]; - record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_552] = [__v_9, __v_10]; + record.function_queries[552].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47704,40 +48948,41 @@ fn aiur_fn_546( }) } -const INPUT_SIZE_547: usize = 7; -const IN_547: usize = 7; -const OUT_547: usize = 2; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_553: usize = 7; +const IN_553: usize = 7; +const OUT_553: usize = 2; +fn aiur_fn_553( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_547], ExecError> { +) -> Result<[G; OUT_553], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(553); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; match __v_0.as_canonical_u64() { _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_547] = [__v_12, __v_13]; - record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_553] = [__v_12, __v_13]; + record.function_queries[553].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -47746,20 +48991,21 @@ fn aiur_fn_547( }) } -const INPUT_SIZE_548: usize = 3; -const IN_548: usize = 3; -const OUT_548: usize = 2; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_554: usize = 3; +const IN_554: usize = 3; +const OUT_554: usize = 2; +fn aiur_fn_554( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_548], ExecError> { +) -> Result<[G; OUT_554], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(554); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -47767,7 +49013,7 @@ fn aiur_fn_548( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -47775,25 +49021,25 @@ fn aiur_fn_548( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_13, __v_14]; - record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_554] = [__v_13, __v_14]; + record.function_queries[554].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[535].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i)?; } record.function_queries[535].output_at(__i).to_array::() }, _ => aiur_fn_535(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_13, __v_14]; - record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_554] = [__v_13, __v_14]; + record.function_queries[554].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -47801,25 +49047,25 @@ fn aiur_fn_548( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[537].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i)?; } record.function_queries[537].output_at(__i).to_array::() }, _ => aiur_fn_537(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_13, __v_14]; - record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_554] = [__v_13, __v_14]; + record.function_queries[554].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[553].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[553].bump_multiplicity(__i)?; } record.function_queries[553].output_at(__i).to_array::() }, _ => aiur_fn_553(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_7, __v_12, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[554].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i)?; } record.function_queries[554].output_at(__i).to_array::() }, _ => aiur_fn_554(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_548] = [__v_17, __v_18]; - record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_554] = [__v_17, __v_18]; + record.function_queries[554].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -47834,75 +49080,76 @@ fn aiur_fn_548( }) } -const INPUT_SIZE_549: usize = 12; -const IN_549: usize = 12; -const OUT_549: usize = 1; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_555: usize = 12; +const IN_555: usize = 12; +const OUT_555: usize = 1; +fn aiur_fn_555( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_549], ExecError> { +) -> Result<[G; OUT_555], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(555); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_549] = [__v_12]; - record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_555] = [__v_12]; + record.function_queries[555].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -47912,134 +49159,136 @@ fn aiur_fn_549( }) } -const INPUT_SIZE_550: usize = 25; -const IN_550: usize = 25; -const OUT_550: usize = 2; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_556: usize = 25; +const IN_556: usize = 25; +const OUT_556: usize = 2; +fn aiur_fn_556( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_550], ExecError> { +) -> Result<[G; OUT_556], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; + record.checkpoint(556); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[555].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i)?; } record.function_queries[555].output_at(__i).to_array::() }, _ => aiur_fn_555(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[555].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i)?; } record.function_queries[555].output_at(__i).to_array::() }, _ => aiur_fn_555(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[557].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[557].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[557].bump_multiplicity(__i)?; } record.function_queries[557].output_at(__i).to_array::() }, _ => aiur_fn_557(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_28, __v_29]; - record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_556] = [__v_28, __v_29]; + record.function_queries[556].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_550] = [__v_28, __v_29]; - record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_556] = [__v_28, __v_29]; + record.function_queries[556].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_551: usize = 25; -const IN_551: usize = 25; -const OUT_551: usize = 2; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_557: usize = 25; +const IN_557: usize = 25; +const OUT_557: usize = 2; +fn aiur_fn_557( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_551], ExecError> { +) -> Result<[G; OUT_557], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; + record.checkpoint(557); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; match __v_0.as_canonical_u64() { 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_14, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3, __v_15, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_26, __v_27, __v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_34, __v_35]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_34, __v_35]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_25, __v_26]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -48047,75 +49296,75 @@ fn aiur_fn_551( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_32, __v_33, __v_35, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_29, __v_30, __v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_26, __v_27, __v_39, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_14, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[558].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i)?; } record.function_queries[558].output_at(__i).to_array::() }, _ => aiur_fn_558(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_44, __v_45, __v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_41, __v_42, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_51, __v_52]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_51, __v_52]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_41, __v_42, __v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_46, __v_47]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_46, __v_47]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_25, __v_26]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -48123,120 +49372,121 @@ fn aiur_fn_551( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_4, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_8, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_8, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_14, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_7, __v_19, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[554].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i)?; } record.function_queries[554].output_at(__i).to_array::() }, _ => aiur_fn_554(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_43, __v_44, __v_45, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_41, __v_42, __v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_38, __v_39, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_35, __v_36, __v_51, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_32, __v_33, __v_53, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_29, __v_30, __v_55, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_26, __v_27, __v_57, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_59, __v_60]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_59, __v_60]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_25, __v_26]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_551] = [__v_25, __v_26]; - record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_557] = [__v_25, __v_26]; + record.function_queries[557].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_552: usize = 7; -const IN_552: usize = 7; -const OUT_552: usize = 2; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_558: usize = 7; +const IN_558: usize = 7; +const OUT_558: usize = 2; +fn aiur_fn_558( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_552], ExecError> { +) -> Result<[G; OUT_558], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(558); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[536].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i)?; } record.function_queries[536].output_at(__i).to_array::() }, _ => aiur_fn_536(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_8, __v_9]; - record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_558] = [__v_8, __v_9]; + record.function_queries[558].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -48249,9 +49499,9 @@ fn aiur_fn_552( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2, __v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; @@ -48264,152 +49514,154 @@ fn aiur_fn_552( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[553].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[559].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[559].bump_multiplicity(__i)?; } record.function_queries[559].output_at(__i).to_array::() }, _ => aiur_fn_559(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[558].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i)?; } record.function_queries[558].output_at(__i).to_array::() }, _ => aiur_fn_558(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_34, __v_35, __v_38, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_552] = [__v_40, __v_41]; - record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_558] = [__v_40, __v_41]; + record.function_queries[558].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_553: usize = 25; -const IN_553: usize = 25; -const OUT_553: usize = 2; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_559: usize = 25; +const IN_559: usize = 25; +const OUT_559: usize = 2; +fn aiur_fn_559( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], ExecError> { +) -> Result<[G; OUT_559], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; + record.checkpoint(559); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; match __v_0.as_canonical_u64() { 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_1, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_5, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_6, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_7, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_14, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[551].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i)?; } record.function_queries[551].output_at(__i).to_array::() }, _ => aiur_fn_551(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_35, __v_36, __v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_32, __v_33, __v_39, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_29, __v_30, __v_41, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_26, __v_27, __v_43, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[538].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i)?; } record.function_queries[538].output_at(__i).to_array::() }, _ => aiur_fn_538(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_45, __v_46]; - record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_559] = [__v_45, __v_46]; + record.function_queries[559].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[555].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i)?; } record.function_queries[555].output_at(__i).to_array::() }, _ => aiur_fn_555(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[555].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i)?; } record.function_queries[555].output_at(__i).to_array::() }, _ => aiur_fn_555(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_28, __v_29]; - record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_559] = [__v_28, __v_29]; + record.function_queries[559].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[555].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i)?; } record.function_queries[555].output_at(__i).to_array::() }, _ => aiur_fn_555(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[555].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i)?; } record.function_queries[555].output_at(__i).to_array::() }, _ => aiur_fn_555(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[533].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i)?; } record.function_queries[533].output_at(__i).to_array::() }, _ => aiur_fn_533(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[539].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i)?; } record.function_queries[539].output_at(__i).to_array::() }, _ => aiur_fn_539(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_553] = [__v_28, __v_29]; - record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_559] = [__v_28, __v_29]; + record.function_queries[559].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_554: usize = 3; -const IN_554: usize = 3; -const OUT_554: usize = 1; -fn aiur_fn_554( - inp: [G; IN_554], +const INPUT_SIZE_560: usize = 3; +const IN_560: usize = 3; +const OUT_560: usize = 1; +fn aiur_fn_560( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_554], ExecError> { +) -> Result<[G; OUT_560], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(560); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[295].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i)?; } record.function_queries[295].output_at(__i).to_array::() }, _ => aiur_fn_295(__key, 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]; @@ -48418,7 +49670,7 @@ fn aiur_fn_554( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[295].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i)?; } record.function_queries[295].output_at(__i).to_array::() }, _ => aiur_fn_295(__key, 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]; @@ -48430,43 +49682,44 @@ fn aiur_fn_554( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_0, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[73].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i)?; } record.function_queries[73].output_at(__i).to_array::() }, _ => aiur_fn_73(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_554] = [__v_34]; - record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_560] = [__v_34]; + record.function_queries[560].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_555: usize = 2; -const IN_555: usize = 2; -const OUT_555: usize = 12; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_561: usize = 2; +const IN_561: usize = 2; +const OUT_561: usize = 12; +fn aiur_fn_561( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], ExecError> { +) -> Result<[G; OUT_561], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + record.checkpoint(561); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -48479,25 +49732,26 @@ fn aiur_fn_555( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_555] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_561] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[561].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_556: usize = 2; -const IN_556: usize = 2; -const OUT_556: usize = 1; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_562: usize = 2; +const IN_562: usize = 2; +const OUT_562: usize = 1; +fn aiur_fn_562( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_556], ExecError> { +) -> Result<[G; OUT_562], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; + record.checkpoint(562); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[561].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i)?; } record.function_queries[561].output_at(__i).to_array::() }, _ => aiur_fn_561(__key, 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]; @@ -48512,60 +49766,62 @@ fn aiur_fn_556( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_556] = [__v_7]; - record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_562] = [__v_7]; + record.function_queries[562].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_556] = [__v_14]; - record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_562] = [__v_14]; + record.function_queries[562].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_557: usize = 3; -const IN_557: usize = 3; -const OUT_557: usize = 1; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_563: usize = 3; +const IN_563: usize = 3; +const OUT_563: usize = 1; +fn aiur_fn_563( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_557], ExecError> { +) -> Result<[G; OUT_563], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(563); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[558].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[564].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i)?; } record.function_queries[564].output_at(__i).to_array::() }, _ => aiur_fn_564(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_557] = [__v_5]; - record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_563] = [__v_5]; + record.function_queries[563].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_558: usize = 5; -const IN_558: usize = 5; -const OUT_558: usize = 1; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_564: usize = 5; +const IN_564: usize = 5; +const OUT_564: usize = 1; +fn aiur_fn_564( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_558], ExecError> { +) -> Result<[G; OUT_564], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(564); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48573,24 +49829,24 @@ fn aiur_fn_558( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_558] = [__v_10]; - record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_564] = [__v_10]; + record.function_queries[564].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[559].bump_multiplicity(__i); } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[565].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i)?; } record.function_queries[565].output_at(__i).to_array::() }, _ => aiur_fn_565(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[558].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[564].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i)?; } record.function_queries[564].output_at(__i).to_array::() }, _ => aiur_fn_564(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[765].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i)?; } record.function_queries[765].output_at(__i).to_array::() }, _ => aiur_fn_765(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_558] = [__v_14]; - record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_564] = [__v_14]; + record.function_queries[564].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -48600,22 +49856,23 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 5; -const IN_559: usize = 5; -const OUT_559: usize = 2; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_565: usize = 5; +const IN_565: usize = 5; +const OUT_565: usize = 2; +fn aiur_fn_565( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], ExecError> { +) -> Result<[G; OUT_565], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(565); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -48623,37 +49880,37 @@ fn aiur_fn_559( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_559] = [__v_10, __v_11]; - record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_565] = [__v_10, __v_11]; + record.function_queries[565].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[559].bump_multiplicity(__i); } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[565].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i)?; } record.function_queries[565].output_at(__i).to_array::() }, _ => aiur_fn_565(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[562].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[562].bump_multiplicity(__i)?; } record.function_queries[562].output_at(__i).to_array::() }, _ => aiur_fn_562(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[566].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i)?; } record.function_queries[566].output_at(__i).to_array::() }, _ => aiur_fn_566(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_12, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[765].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i)?; } record.function_queries[765].output_at(__i).to_array::() }, _ => aiur_fn_765(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_559] = [__v_16, __v_10]; - record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_565] = [__v_16, __v_10]; + record.function_queries[565].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_559] = [__v_16, __v_9]; - record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_565] = [__v_16, __v_9]; + record.function_queries[565].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -48665,122 +49922,125 @@ fn aiur_fn_559( }) } -const INPUT_SIZE_560: usize = 5; -const IN_560: usize = 5; -const OUT_560: usize = 1; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_566: usize = 5; +const IN_566: usize = 5; +const OUT_566: usize = 1; +fn aiur_fn_566( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_560], ExecError> { +) -> Result<[G; OUT_566], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(566); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = (__v_2 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_560] = [__v_8]; - record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_566] = [__v_8]; + record.function_queries[566].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[560].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i)?; } record.function_queries[560].output_at(__i).to_array::() }, _ => aiur_fn_560(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[566].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i)?; } record.function_queries[566].output_at(__i).to_array::() }, _ => aiur_fn_566(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_560] = [__v_12]; - record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_566] = [__v_12]; + record.function_queries[566].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_561: usize = 3; -const IN_561: usize = 3; -const OUT_561: usize = 1; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_567: usize = 3; +const IN_567: usize = 3; +const OUT_567: usize = 1; +fn aiur_fn_567( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_561], ExecError> { +) -> Result<[G; OUT_567], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(567); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[562].bump_multiplicity(__i); } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[568].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i)?; } record.function_queries[568].output_at(__i).to_array::() }, _ => aiur_fn_568(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_561] = [__v_11]; - record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_567] = [__v_11]; + record.function_queries[567].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_562: usize = 4; -const IN_562: usize = 4; -const OUT_562: usize = 1; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_568: usize = 4; +const IN_568: usize = 4; +const OUT_568: usize = 1; +fn aiur_fn_568( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_562], ExecError> { +) -> Result<[G; OUT_568], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(568); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_562] = [__v_0]; - record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_568] = [__v_0]; + record.function_queries[568].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[558].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[564].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i)?; } record.function_queries[564].output_at(__i).to_array::() }, _ => aiur_fn_564(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[563].bump_multiplicity(__i); } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[569].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i)?; } record.function_queries[569].output_at(__i).to_array::() }, _ => aiur_fn_569(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[575].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i)?; } record.function_queries[575].output_at(__i).to_array::() }, _ => aiur_fn_575(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_562] = [__v_0]; - record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_568] = [__v_0]; + record.function_queries[568].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[562].bump_multiplicity(__i); } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[568].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i)?; } record.function_queries[568].output_at(__i).to_array::() }, _ => aiur_fn_568(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_562] = [__v_11]; - record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_568] = [__v_11]; + record.function_queries[568].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -48789,20 +50049,21 @@ fn aiur_fn_562( }) } -const INPUT_SIZE_563: usize = 3; -const IN_563: usize = 3; -const OUT_563: usize = 1; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_569: usize = 3; +const IN_569: usize = 3; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_563], ExecError> { +) -> Result<[G; OUT_569], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(569); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -48810,20 +50071,20 @@ fn aiur_fn_563( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_563] = [__v_8]; - record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_569] = [__v_8]; + record.function_queries[569].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[564].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i); } let __ret: [G; OUT_564] = unsafe { *(record.function_queries[564].output_at(__i).as_ptr() as *const [G; OUT_564]) }; __ret }, _ => aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[570].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i)?; } record.function_queries[570].output_at(__i).to_array::() }, _ => aiur_fn_570(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[563].bump_multiplicity(__i); } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[569].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i)?; } record.function_queries[569].output_at(__i).to_array::() }, _ => aiur_fn_569(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_563] = [__v_8]; - record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_569] = [__v_8]; + record.function_queries[569].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -48833,67 +50094,69 @@ fn aiur_fn_563( }) } -const INPUT_SIZE_564: usize = 3; -const IN_564: usize = 3; -const OUT_564: usize = 1; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_570: usize = 3; +const IN_570: usize = 3; +const OUT_570: usize = 1; +fn aiur_fn_570( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_564], ExecError> { +) -> Result<[G; OUT_570], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + record.checkpoint(570); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_564] = [__v_6]; - record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_570] = [__v_6]; + record.function_queries[570].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_564] = [__v_8]; - record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_0, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_570] = [__v_8]; + record.function_queries[570].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[571].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i)?; } record.function_queries[571].output_at(__i).to_array::() }, _ => aiur_fn_571(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[567].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[567].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[567].bump_multiplicity(__i); } let __ret: [G; OUT_567] = unsafe { *(record.function_queries[567].output_at(__i).as_ptr() as *const [G; OUT_567]) }; __ret }, _ => aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[573].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i)?; } record.function_queries[573].output_at(__i).to_array::() }, _ => aiur_fn_573(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_564] = [__v_5]; - record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_570] = [__v_5]; + record.function_queries[570].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_565: usize = 3; -const IN_565: usize = 3; -const OUT_565: usize = 1; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_571: usize = 3; +const IN_571: usize = 3; +const OUT_571: usize = 1; +fn aiur_fn_571( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_565], ExecError> { +) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(571); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -48901,18 +50164,18 @@ fn aiur_fn_565( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_565] = [__v_8]; - record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_571] = [__v_8]; + record.function_queries[571].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[571].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i)?; } record.function_queries[571].output_at(__i).to_array::() }, _ => aiur_fn_571(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[572].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[572].bump_multiplicity(__i)?; } record.function_queries[572].output_at(__i).to_array::() }, _ => aiur_fn_572(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_565] = [__v_7]; - record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_571] = [__v_7]; + record.function_queries[571].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -48922,21 +50185,22 @@ fn aiur_fn_565( }) } -const INPUT_SIZE_566: usize = 4; -const IN_566: usize = 4; -const OUT_566: usize = 1; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_572: usize = 4; +const IN_572: usize = 4; +const OUT_572: usize = 1; +fn aiur_fn_572( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_566], ExecError> { +) -> Result<[G; OUT_572], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(572); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -48945,14 +50209,14 @@ fn aiur_fn_566( let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_566] = [__v_11]; - record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_572] = [__v_11]; + record.function_queries[572].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_3, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[561].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i)?; } record.function_queries[561].output_at(__i).to_array::() }, _ => aiur_fn_561(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -48965,7 +50229,7 @@ fn aiur_fn_566( let __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[561].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i)?; } record.function_queries[561].output_at(__i).to_array::() }, _ => aiur_fn_561(__key, 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]; @@ -48978,24 +50242,24 @@ fn aiur_fn_566( let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i); } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[556].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i)?; } record.function_queries[556].output_at(__i).to_array::() }, _ => aiur_fn_556(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { 0u64 => { let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_566] = [__v_34]; - record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained); + let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_572] = [__v_34]; + record.function_queries[572].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_0, __v_6, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[572].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[572].bump_multiplicity(__i)?; } record.function_queries[572].output_at(__i).to_array::() }, _ => aiur_fn_572(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_566] = [__v_35]; - record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_5, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_572] = [__v_35]; + record.function_queries[572].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49007,20 +50271,21 @@ fn aiur_fn_566( }) } -const INPUT_SIZE_567: usize = 3; -const IN_567: usize = 3; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_573: usize = 3; +const IN_573: usize = 3; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_567], ExecError> { +) -> Result<[G; OUT_573], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(573); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -49028,21 +50293,21 @@ fn aiur_fn_567( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_567] = [__v_8]; - record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_573] = [__v_8]; + record.function_queries[573].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i); } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_4, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[574].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i)?; } record.function_queries[574].output_at(__i).to_array::() }, _ => aiur_fn_574(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_567] = [__v_11]; - record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_573] = [__v_11]; + record.function_queries[573].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49052,22 +50317,23 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 5; -const IN_568: usize = 5; -const OUT_568: usize = 1; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_574: usize = 5; +const IN_574: usize = 5; +const OUT_574: usize = 1; +fn aiur_fn_574( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_568], ExecError> { +) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(574); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -49076,14 +50342,14 @@ fn aiur_fn_568( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_568] = [__v_12]; - record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_574] = [__v_12]; + record.function_queries[574].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[561].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i)?; } record.function_queries[561].output_at(__i).to_array::() }, _ => aiur_fn_561(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -49096,7 +50362,7 @@ fn aiur_fn_568( let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[561].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i)?; } record.function_queries[561].output_at(__i).to_array::() }, _ => aiur_fn_561(__key, 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]; @@ -49109,17 +50375,17 @@ fn aiur_fn_568( let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i); } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[556].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i)?; } record.function_queries[556].output_at(__i).to_array::() }, _ => aiur_fn_556(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[763].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i)?; } record.function_queries[763].output_at(__i).to_array::() }, _ => aiur_fn_763(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i); } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[574].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i)?; } record.function_queries[574].output_at(__i).to_array::() }, _ => aiur_fn_574(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_568] = [__v_35]; - record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_574] = [__v_35]; + record.function_queries[574].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49127,13 +50393,13 @@ fn aiur_fn_568( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i); } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[574].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i)?; } record.function_queries[574].output_at(__i).to_array::() }, _ => aiur_fn_574(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_568] = [__v_41]; - record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained); + let __v_41: G = { let __values: [G; 3] = [__v_34, __v_4, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_574] = [__v_41]; + record.function_queries[574].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49145,70 +50411,71 @@ fn aiur_fn_568( }) } -const INPUT_SIZE_569: usize = 2; -const IN_569: usize = 2; -const OUT_569: usize = 1; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_575: usize = 2; +const IN_575: usize = 2; +const OUT_575: usize = 1; +fn aiur_fn_575( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], ExecError> { +) -> Result<[G; OUT_575], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(575); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_569] = [__v_8]; - record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_575] = [__v_8]; + record.function_queries[575].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_8]; - record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_575] = [__v_8]; + record.function_queries[575].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_8]; - record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_575] = [__v_8]; + record.function_queries[575].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[341].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i)?; } record.function_queries[341].output_at(__i).to_array::() }, _ => aiur_fn_341(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_569] = [__v_9]; - record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_575] = [__v_9]; + record.function_queries[575].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[575].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i)?; } record.function_queries[575].output_at(__i).to_array::() }, _ => aiur_fn_575(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_569] = [__v_9]; - record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_575] = [__v_9]; + record.function_queries[575].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49225,18 +50492,19 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 1; -const IN_570: usize = 1; -const OUT_570: usize = 1; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_576: usize = 1; +const IN_576: usize = 1; +const OUT_576: usize = 1; +fn aiur_fn_576( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_570], ExecError> { +) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(576); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -49244,18 +50512,18 @@ fn aiur_fn_570( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_570] = [__v_6]; - record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_576] = [__v_6]; + record.function_queries[576].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[576].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i)?; } record.function_queries[576].output_at(__i).to_array::() }, _ => aiur_fn_576(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_570] = [__v_5]; - record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_576] = [__v_5]; + record.function_queries[576].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49265,43 +50533,44 @@ fn aiur_fn_570( }) } -const INPUT_SIZE_571: usize = 1; -const IN_571: usize = 1; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_577: usize = 1; +const IN_577: usize = 1; +const OUT_577: usize = 1; +fn aiur_fn_577( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_571], ExecError> { +) -> Result<[G; OUT_577], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(577); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_571] = [__v_4]; - record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_577] = [__v_4]; + record.function_queries[577].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[577].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i)?; } record.function_queries[577].output_at(__i).to_array::() }, _ => aiur_fn_577(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_5]; - record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_577] = [__v_5]; + record.function_queries[577].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_571] = [__v_5]; - record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_577] = [__v_5]; + record.function_queries[577].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49313,19 +50582,20 @@ fn aiur_fn_571( }) } -const INPUT_SIZE_572: usize = 2; -const IN_572: usize = 2; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_578: usize = 2; +const IN_578: usize = 2; +const OUT_578: usize = 1; +fn aiur_fn_578( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_572], ExecError> { +) -> Result<[G; OUT_578], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(578); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -49377,27 +50647,27 @@ fn aiur_fn_572( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); - let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_572] = [__v_51]; - record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_578] = [__v_51]; + record.function_queries[578].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_48, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[578].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i)?; } record.function_queries[578].output_at(__i).to_array::() }, _ => aiur_fn_578(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); - let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_572] = [__v_53]; - record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained); + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_578] = [__v_53]; + record.function_queries[578].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_572] = [__v_51]; - record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_578] = [__v_51]; + record.function_queries[578].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49409,19 +50679,20 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 2; -const IN_573: usize = 2; -const OUT_573: usize = 1; -fn aiur_fn_573( - inp: [G; IN_573], +const INPUT_SIZE_579: usize = 2; +const IN_579: usize = 2; +const OUT_579: usize = 1; +fn aiur_fn_579( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_573], ExecError> { +) -> Result<[G; OUT_579], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(579); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -49472,8 +50743,8 @@ fn aiur_fn_573( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_49]; - record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_579] = [__v_49]; + record.function_queries[579].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -49499,15 +50770,15 @@ fn aiur_fn_573( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_573] = [__v_50]; - record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_579] = [__v_50]; + record.function_queries[579].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_48, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[579].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i)?; } record.function_queries[579].output_at(__i).to_array::() }, _ => aiur_fn_579(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_573] = [__v_50]; - record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_579] = [__v_50]; + record.function_queries[579].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49519,18 +50790,19 @@ fn aiur_fn_573( }) } -const INPUT_SIZE_574: usize = 1; -const IN_574: usize = 1; -const OUT_574: usize = 0; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_580: usize = 1; +const IN_580: usize = 1; +const OUT_580: usize = 0; +fn aiur_fn_580( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], ExecError> { +) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(580); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -49584,66 +50856,66 @@ fn aiur_fn_574( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_2, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[578].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i)?; } record.function_queries[578].output_at(__i).to_array::() }, _ => aiur_fn_578(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_2, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[579].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i)?; } record.function_queries[579].output_at(__i).to_array::() }, _ => aiur_fn_579(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_2, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[579].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i)?; } record.function_queries[579].output_at(__i).to_array::() }, _ => aiur_fn_579(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_52 * __v_54); let __v_56: G = G::from_u64(0); if (__v_55 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); - let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_574] = []; - record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_580] = []; + record.function_queries[580].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[297].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i)?; } record.function_queries[297].output_at(__i).to_array::() }, _ => aiur_fn_297(__key, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); let __v_63: G = G::from_u64(1); - let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_66: G = G::from_u64(1); - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[562].bump_multiplicity(__i); } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_65, __v_60, __v_0, __v_68]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[568].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i)?; } record.function_queries[568].output_at(__i).to_array::() }, _ => aiur_fn_568(__key, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_69]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[577].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i)?; } record.function_queries[577].output_at(__i).to_array::() }, _ => aiur_fn_577(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_69]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[576].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i)?; } record.function_queries[576].output_at(__i).to_array::() }, _ => aiur_fn_576(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_72, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_72, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[341].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i)?; } record.function_queries[341].output_at(__i).to_array::() }, _ => aiur_fn_341(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_574] = []; - record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_580] = []; + record.function_queries[580].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_574] = []; - record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_580] = []; + record.function_queries[580].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -49652,80 +50924,81 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 12; -const IN_575: usize = 12; -const OUT_575: usize = 1; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_581: usize = 12; +const IN_581: usize = 12; +const OUT_581: usize = 1; +fn aiur_fn_581( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_575], ExecError> { +) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(581); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_575] = [__v_3]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_3]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_12]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_12]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_575] = [__v_12]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_12]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_12]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_12]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_575] = [__v_4]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_4]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_12]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_12]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_575] = [__v_6]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_6]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_575] = [__v_8]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_8]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_575] = [__v_9]; - record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_581] = [__v_9]; + record.function_queries[581].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49735,18 +51008,19 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 1; -const IN_576: usize = 1; -const OUT_576: usize = 1; -fn aiur_fn_576( - inp: [G; IN_576], +const INPUT_SIZE_582: usize = 1; +const IN_582: usize = 1; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_576], ExecError> { +) -> Result<[G; OUT_582], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(582); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -49754,20 +51028,20 @@ fn aiur_fn_576( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_5]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_5]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_5]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_5]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -49781,67 +51055,67 @@ fn aiur_fn_576( let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i); } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[581].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i)?; } record.function_queries[581].output_at(__i).to_array::() }, _ => aiur_fn_581(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_576] = [__v_20]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_20]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_576] = [__v_7]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_7]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_576] = [__v_7]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_7]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_576] = [__v_7]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_7]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); - let __ret: [G; OUT_576] = [__v_9]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_9]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_576] = [__v_5]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_5]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_576] = [__v_5]; - record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_582] = [__v_5]; + record.function_queries[582].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49851,89 +51125,91 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 2; -const IN_577: usize = 2; -const OUT_577: usize = 0; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_583: usize = 2; +const IN_583: usize = 2; +const OUT_583: usize = 0; +fn aiur_fn_583( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], ExecError> { +) -> Result<[G; OUT_583], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(583); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_577] = []; - record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_583] = []; + record.function_queries[583].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[582].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i)?; } record.function_queries[582].output_at(__i).to_array::() }, _ => aiur_fn_582(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } - let __ret: [G; OUT_577] = []; - record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_583] = []; + record.function_queries[583].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_578: usize = 2; -const IN_578: usize = 2; -const OUT_578: usize = 0; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_584: usize = 2; +const IN_584: usize = 2; +const OUT_584: usize = 0; +fn aiur_fn_584( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_578], ExecError> { +) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(584); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_578] = []; - record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_584] = []; + record.function_queries[584].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_578] = []; - record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_584] = []; + record.function_queries[584].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_578] = []; - record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_584] = []; + record.function_queries[584].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_578] = []; - record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_584] = []; + record.function_queries[584].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } - let __ret: [G; OUT_578] = []; - record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_584] = []; + record.function_queries[584].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49943,33 +51219,34 @@ fn aiur_fn_578( }) } -const INPUT_SIZE_579: usize = 2; -const IN_579: usize = 2; -const OUT_579: usize = 0; -fn aiur_fn_579( - inp: [G; IN_579], +const INPUT_SIZE_585: usize = 2; +const IN_585: usize = 2; +const OUT_585: usize = 0; +fn aiur_fn_585( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], ExecError> { +) -> Result<[G; OUT_585], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(585); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_579] = []; - record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_585] = []; + record.function_queries[585].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[585].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i)?; } record.function_queries[585].output_at(__i).to_array::() }, _ => aiur_fn_585(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_585] = []; + record.function_queries[585].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -49979,45 +51256,46 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 3; -const IN_580: usize = 3; -const OUT_580: usize = 0; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_586: usize = 3; +const IN_586: usize = 3; +const OUT_586: usize = 0; +fn aiur_fn_586( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], ExecError> { +) -> Result<[G; OUT_586], ExecError> { stacker::maybe_grow(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; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(586); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) }); } - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[584].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i)?; } record.function_queries[584].output_at(__i).to_array::() }, _ => aiur_fn_584(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -50030,62 +51308,62 @@ fn aiur_fn_580( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[436].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i)?; } record.function_queries[436].output_at(__i).to_array::() }, _ => aiur_fn_436(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[585].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i)?; } record.function_queries[585].output_at(__i).to_array::() }, _ => aiur_fn_585(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_586] = []; + record.function_queries[586].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50095,16 +51373,17 @@ fn aiur_fn_580( }) } -const INPUT_SIZE_581: usize = 0; -const IN_581: usize = 0; -const OUT_581: usize = 1; -fn aiur_fn_581( - inp: [G; IN_581], +const INPUT_SIZE_587: usize = 0; +const IN_587: usize = 0; +const OUT_587: usize = 1; +fn aiur_fn_587( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_581], ExecError> { +) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(587); let __v_0: G = G::from_u64(231); let __v_1: G = G::from_u64(117); let __v_2: G = G::from_u64(170); @@ -50137,23 +51416,24 @@ fn aiur_fn_581( let __v_29: G = G::from_u64(147); let __v_30: G = G::from_u64(27); let __v_31: G = G::from_u64(75); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_581] = [__v_32]; - record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_587] = [__v_32]; + record.function_queries[587].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_582: usize = 0; -const IN_582: usize = 0; -const OUT_582: usize = 1; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_588: usize = 0; +const IN_588: usize = 0; +const OUT_588: usize = 1; +fn aiur_fn_588( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], ExecError> { +) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + record.checkpoint(588); let __v_0: G = G::from_u64(178); let __v_1: G = G::from_u64(14); let __v_2: G = G::from_u64(161); @@ -50186,36 +51466,37 @@ fn aiur_fn_582( let __v_29: G = G::from_u64(62); let __v_30: G = G::from_u64(149); let __v_31: G = G::from_u64(149); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_582] = [__v_32]; - record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_588] = [__v_32]; + record.function_queries[588].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_583: usize = 3; -const IN_583: usize = 3; -const OUT_583: usize = 1; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_589: usize = 3; +const IN_589: usize = 3; +const OUT_589: usize = 1; +fn aiur_fn_589( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_583], ExecError> { +) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(589); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_583] = [__v_4]; - record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_589] = [__v_4]; + record.function_queries[589].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50224,16 +51505,16 @@ fn aiur_fn_583( 5u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[589].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i)?; } record.function_queries[589].output_at(__i).to_array::() }, _ => aiur_fn_589(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_583] = [__v_10]; - record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_589] = [__v_10]; + record.function_queries[589].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_583] = [__v_8]; - record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_589] = [__v_8]; + record.function_queries[589].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -50242,21 +51523,22 @@ fn aiur_fn_583( }) } -const INPUT_SIZE_584: usize = 0; -const IN_584: usize = 0; -const OUT_584: usize = 0; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_590: usize = 0; +const IN_590: usize = 0; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], ExecError> { +) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = []; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } }; + record.checkpoint(590); + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[588].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i)?; } record.function_queries[588].output_at(__i).to_array::() }, _ => aiur_fn_588(__key, record, io_buffer, __cu)? } }; let __v_0: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -50283,8 +51565,8 @@ fn aiur_fn_584( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_584] = []; - record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_590] = []; + record.function_queries[590].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50294,25 +51576,26 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 4; -const IN_585: usize = 4; -const OUT_585: usize = 0; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_591: usize = 4; +const IN_591: usize = 4; +const OUT_591: usize = 0; +fn aiur_fn_591( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], ExecError> { +) -> Result<[G; OUT_591], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(591); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = []; let __cu = unconstrained; let __hit = record.function_queries[581].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[587].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i)?; } record.function_queries[587].output_at(__i).to_array::() }, _ => aiur_fn_587(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50323,9 +51606,9 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[388].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[388].bump_multiplicity(__i)?; } record.function_queries[388].output_at(__i).to_array::() }, _ => aiur_fn_388(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50336,10 +51619,10 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = []; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[590].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i)?; } record.function_queries[590].output_at(__i).to_array::() }, _ => aiur_fn_590(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[389].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[389].bump_multiplicity(__i)?; } record.function_queries[389].output_at(__i).to_array::() }, _ => aiur_fn_389(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50350,9 +51633,9 @@ fn aiur_fn_585( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = []; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[390].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i)?; } record.function_queries[390].output_at(__i).to_array::() }, _ => aiur_fn_390(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); if (__v_5 != __v_6) { @@ -50373,38 +51656,39 @@ fn aiur_fn_585( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[589].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i)?; } record.function_queries[589].output_at(__i).to_array::() }, _ => aiur_fn_589(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) }); } - let __ret: [G; OUT_585] = []; - record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_591] = []; + record.function_queries[591].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_586: usize = 2; -const IN_586: usize = 2; -const OUT_586: usize = 1; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_592: usize = 2; +const IN_592: usize = 2; +const OUT_592: usize = 1; +fn aiur_fn_592( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], ExecError> { +) -> Result<[G; OUT_592], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(592); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_586] = [__v_0]; - record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_592] = [__v_0]; + record.function_queries[592].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -50413,10 +51697,10 @@ fn aiur_fn_586( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_586] = [__v_8]; - record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_592] = [__v_8]; + record.function_queries[592].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50428,39 +51712,40 @@ fn aiur_fn_586( }) } -const INPUT_SIZE_587: usize = 3; -const IN_587: usize = 3; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_593: usize = 3; +const IN_593: usize = 3; +const OUT_593: usize = 0; +fn aiur_fn_593( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], ExecError> { +) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(593); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } - let __ret: [G; OUT_587] = []; - record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_593] = []; + record.function_queries[593].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -50470,12 +51755,12 @@ fn aiur_fn_587( let __v_10: G = (__v_1 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_5, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[593].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i)?; } record.function_queries[593].output_at(__i).to_array::() }, _ => aiur_fn_593(__key, record, io_buffer, __cu)? } }; if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } - let __ret: [G; OUT_587] = []; - record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_593] = []; + record.function_queries[593].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50492,35 +51777,36 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 4; -const IN_588: usize = 4; -const OUT_588: usize = 0; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_594: usize = 4; +const IN_594: usize = 4; +const OUT_594: usize = 0; +fn aiur_fn_594( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], ExecError> { +) -> Result<[G; OUT_594], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(594); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_588] = []; - record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_594] = []; + record.function_queries[594].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -50529,7 +51815,7 @@ fn aiur_fn_588( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_7, __v_1, __v_2, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[594].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i)?; } record.function_queries[594].output_at(__i).to_array::() }, _ => aiur_fn_594(__key, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -50537,8 +51823,8 @@ fn aiur_fn_588( if (__v_9 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } - let __ret: [G; OUT_588] = []; - record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_594] = []; + record.function_queries[594].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50555,22 +51841,23 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 3; -const IN_589: usize = 3; -const OUT_589: usize = 0; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_595: usize = 3; +const IN_595: usize = 3; +const OUT_595: usize = 0; +fn aiur_fn_595( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], ExecError> { +) -> Result<[G; OUT_595], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(595); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50585,7 +51872,7 @@ fn aiur_fn_589( let __v_15: G = __loaded[11]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); if (__v_16 != __v_17) { @@ -50594,8 +51881,8 @@ fn aiur_fn_589( if (__v_12 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } - let __ret: [G; OUT_589] = []; - record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_595] = []; + record.function_queries[595].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50605,62 +51892,63 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 7; -const IN_590: usize = 7; -const OUT_590: usize = 0; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_596: usize = 7; +const IN_596: usize = 7; +const OUT_596: usize = 0; +fn aiur_fn_596( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], ExecError> { +) -> Result<[G; OUT_596], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(596); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_12, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[595].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[595].bump_multiplicity(__i)?; } record.function_queries[595].output_at(__i).to_array::() }, _ => aiur_fn_595(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_4, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[593].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i)?; } record.function_queries[593].output_at(__i).to_array::() }, _ => aiur_fn_593(__key, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_10, __v_1, __v_3, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[594].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i)?; } record.function_queries[594].output_at(__i).to_array::() }, _ => aiur_fn_594(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_10, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_17, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_17, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[607].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i)?; } record.function_queries[607].output_at(__i).to_array::() }, _ => aiur_fn_607(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } - let __ret: [G; OUT_590] = []; - record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_596] = []; + record.function_queries[596].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50670,54 +51958,55 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 4; -const IN_591: usize = 4; -const OUT_591: usize = 0; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_597: usize = 4; +const IN_597: usize = 4; +const OUT_597: usize = 0; +fn aiur_fn_597( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_591], ExecError> { +) -> Result<[G; OUT_597], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(597); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_591] = []; - record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_597] = []; + record.function_queries[597].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_15: G = G::from_u64(1); if (__v_12 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("ctor parameter type disagrees with the inductive's".to_string()) }); } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_591] = []; - record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_6, __v_10, __v_17, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[597].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i)?; } record.function_queries[597].output_at(__i).to_array::() }, _ => aiur_fn_597(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_597] = []; + record.function_queries[597].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50734,55 +52023,57 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 3; -const IN_592: usize = 3; -const OUT_592: usize = 0; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_598: usize = 3; +const IN_598: usize = 3; +const OUT_598: usize = 0; +fn aiur_fn_598( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], ExecError> { +) -> Result<[G; OUT_598], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(598); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_592] = []; - record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[597].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i)?; } record.function_queries[597].output_at(__i).to_array::() }, _ => aiur_fn_597(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_598] = []; + record.function_queries[598].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_593: usize = 3; -const IN_593: usize = 3; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_599: usize = 3; +const IN_599: usize = 3; +const OUT_599: usize = 1; +fn aiur_fn_599( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_593], ExecError> { +) -> Result<[G; OUT_599], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + record.checkpoint(599); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_593] = [__v_5]; - record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_599] = [__v_5]; + record.function_queries[599].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50791,7 +52082,7 @@ fn aiur_fn_593( } }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50801,11 +52092,11 @@ fn aiur_fn_593( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_593] = [__v_12]; - record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_599] = [__v_12]; + record.function_queries[599].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50817,73 +52108,75 @@ fn aiur_fn_593( }) } -const INPUT_SIZE_594: usize = 3; -const IN_594: usize = 3; -const OUT_594: usize = 0; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_600: usize = 3; +const IN_600: usize = 3; +const OUT_600: usize = 0; +fn aiur_fn_600( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], ExecError> { +) -> Result<[G; OUT_600], ExecError> { stacker::maybe_grow(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; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(600); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[325].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i)?; } record.function_queries[325].output_at(__i).to_array::() }, _ => aiur_fn_325(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("ctor field lives in a universe above the inductive's".to_string()) }); } let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_594] = []; - record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[600].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i)?; } record.function_queries[600].output_at(__i).to_array::() }, _ => aiur_fn_600(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_600] = []; + record.function_queries[600].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_594] = []; - record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_600] = []; + record.function_queries[600].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_595: usize = 4; -const IN_595: usize = 4; -const OUT_595: usize = 0; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_601: usize = 4; +const IN_601: usize = 4; +const OUT_601: usize = 0; +fn aiur_fn_601( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], ExecError> { +) -> Result<[G; OUT_601], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(601); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_595] = []; - record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[600].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i)?; } record.function_queries[600].output_at(__i).to_array::() }, _ => aiur_fn_600(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + record.function_queries[601].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -50893,10 +52186,10 @@ fn aiur_fn_595( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_595] = []; - record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_6, __v_9, __v_2, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[601].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i)?; } record.function_queries[601].output_at(__i).to_array::() }, _ => aiur_fn_601(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_601] = []; + record.function_queries[601].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -50908,100 +52201,103 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 3; -const IN_596: usize = 3; -const OUT_596: usize = 0; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_602: usize = 3; +const IN_602: usize = 3; +const OUT_602: usize = 0; +fn aiur_fn_602( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], ExecError> { +) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(602); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_596] = []; - record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_602] = []; + record.function_queries[602].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_596] = []; - record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_1, __v_2, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[601].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i)?; } record.function_queries[601].output_at(__i).to_array::() }, _ => aiur_fn_601(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_602] = []; + record.function_queries[602].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_597: usize = 2; -const IN_597: usize = 2; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_603: usize = 2; +const IN_603: usize = 2; +const OUT_603: usize = 1; +fn aiur_fn_603( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], ExecError> { +) -> Result<[G; OUT_603], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; + record.checkpoint(603); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[291].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i)?; } record.function_queries[291].output_at(__i).to_array::() }, _ => aiur_fn_291(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_597] = [__v_2]; - record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_603] = [__v_2]; + record.function_queries[603].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_598: usize = 2; -const IN_598: usize = 2; -const OUT_598: usize = 1; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_604: usize = 2; +const IN_604: usize = 2; +const OUT_604: usize = 1; +fn aiur_fn_604( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], ExecError> { +) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(604); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_598] = [__v_5]; - record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_604] = [__v_5]; + record.function_queries[604].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_598] = [__v_6]; - record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_604] = [__v_6]; + record.function_queries[604].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[604].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i)?; } record.function_queries[604].output_at(__i).to_array::() }, _ => aiur_fn_604(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_598] = [__v_6]; - record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_604] = [__v_6]; + record.function_queries[604].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -51013,21 +52309,22 @@ fn aiur_fn_598( }) } -const INPUT_SIZE_599: usize = 2; -const IN_599: usize = 2; -const OUT_599: usize = 1; -fn aiur_fn_599( - inp: [G; IN_599], +const INPUT_SIZE_605: usize = 2; +const IN_605: usize = 2; +const OUT_605: usize = 1; +fn aiur_fn_605( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], ExecError> { +) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(605); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -51042,35 +52339,36 @@ fn aiur_fn_599( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[604].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i)?; } record.function_queries[604].output_at(__i).to_array::() }, _ => aiur_fn_604(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_599] = [__v_15]; - record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_605] = [__v_15]; + record.function_queries[605].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_599] = [__v_15]; - record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_605] = [__v_15]; + record.function_queries[605].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_600: usize = 2; -const IN_600: usize = 2; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_606: usize = 2; +const IN_606: usize = 2; +const OUT_606: usize = 1; +fn aiur_fn_606( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_600], ExecError> { +) -> Result<[G; OUT_606], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(606); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -51078,105 +52376,105 @@ fn aiur_fn_600( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_6]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_6]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[605].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i)?; } record.function_queries[605].output_at(__i).to_array::() }, _ => aiur_fn_605(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_6]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_6]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_7]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_7]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_600] = [__v_8]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_8]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_8]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_8]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -51185,15 +52483,15 @@ fn aiur_fn_600( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_600] = [__v_6]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_6]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_600] = [__v_6]; - record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_606] = [__v_6]; + record.function_queries[606].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -51203,44 +52501,45 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 2; -const IN_601: usize = 2; -const OUT_601: usize = 1; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_607: usize = 2; +const IN_607: usize = 2; +const OUT_607: usize = 1; +fn aiur_fn_607( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], ExecError> { +) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(607); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_601] = [__v_5]; - record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_607] = [__v_5]; + record.function_queries[607].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_601] = [__v_6]; - record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_607] = [__v_6]; + record.function_queries[607].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[607].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i)?; } record.function_queries[607].output_at(__i).to_array::() }, _ => aiur_fn_607(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_601] = [__v_6]; - record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_607] = [__v_6]; + record.function_queries[607].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -51252,27 +52551,28 @@ fn aiur_fn_601( }) } -const INPUT_SIZE_602: usize = 3; -const IN_602: usize = 3; -const OUT_602: usize = 2; -fn aiur_fn_602( - inp: [G; IN_602], +const INPUT_SIZE_608: usize = 3; +const IN_608: usize = 3; +const OUT_608: usize = 2; +fn aiur_fn_608( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_602], ExecError> { +) -> Result<[G; OUT_608], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(608); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_602] = [__v_0, __v_2]; - record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_608] = [__v_0, __v_2]; + record.function_queries[608].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -51280,19 +52580,19 @@ fn aiur_fn_602( match __v_3.as_canonical_u64() { 5u64 => { let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 - __v_9); - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_5, __v_10, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[608].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i)?; } record.function_queries[608].output_at(__i).to_array::() }, _ => aiur_fn_608(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_602] = [__v_11, __v_12]; - record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_608] = [__v_11, __v_12]; + record.function_queries[608].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_602] = [__v_0, __v_2]; - record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_608] = [__v_0, __v_2]; + record.function_queries[608].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -51301,35 +52601,36 @@ fn aiur_fn_602( }) } -const INPUT_SIZE_603: usize = 4; -const IN_603: usize = 4; -const OUT_603: usize = 0; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_609: usize = 4; +const IN_609: usize = 4; +const OUT_609: usize = 0; +fn aiur_fn_609( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], ExecError> { +) -> Result<[G; OUT_609], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(609); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_603] = []; - record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_609] = []; + record.function_queries[609].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -51344,9 +52645,9 @@ fn aiur_fn_603( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_603] = []; - record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_7, __v_1, __v_2, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[609].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i)?; } record.function_queries[609].output_at(__i).to_array::() }, _ => aiur_fn_609(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + record.function_queries[609].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -51363,24 +52664,25 @@ fn aiur_fn_603( }) } -const INPUT_SIZE_604: usize = 5; -const IN_604: usize = 5; -const OUT_604: usize = 0; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_610: usize = 5; +const IN_610: usize = 5; +const OUT_610: usize = 0; +fn aiur_fn_610( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], ExecError> { +) -> Result<[G; OUT_610], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(610); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -51396,25 +52698,25 @@ fn aiur_fn_604( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_1, __v_7, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[593].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i)?; } record.function_queries[593].output_at(__i).to_array::() }, _ => aiur_fn_593(__key, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_9, __v_4, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[609].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i)?; } record.function_queries[609].output_at(__i).to_array::() }, _ => aiur_fn_609(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_9 + __v_10); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_22, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[607].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i)?; } record.function_queries[607].output_at(__i).to_array::() }, _ => aiur_fn_607(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } - let __ret: [G; OUT_604] = []; - record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_610] = []; + record.function_queries[610].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -51424,32 +52726,33 @@ fn aiur_fn_604( }) } -const INPUT_SIZE_605: usize = 4; -const IN_605: usize = 4; -const OUT_605: usize = 0; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_611: usize = 4; +const IN_611: usize = 4; +const OUT_611: usize = 0; +fn aiur_fn_611( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_605], ExecError> { +) -> Result<[G; OUT_611], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + record.checkpoint(611); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_605] = []; - record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_611] = []; + record.function_queries[611].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -51457,53 +52760,53 @@ fn aiur_fn_605( match __v_6.as_canonical_u64() { 5u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[606].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i)?; } record.function_queries[606].output_at(__i).to_array::() }, _ => aiur_fn_606(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_8, __v_1, __v_11, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[611].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i)?; } record.function_queries[611].output_at(__i).to_array::() }, _ => aiur_fn_611(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_611] = []; + record.function_queries[611].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_13, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[605].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i)?; } record.function_queries[605].output_at(__i).to_array::() }, _ => aiur_fn_605(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[610].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i)?; } record.function_queries[610].output_at(__i).to_array::() }, _ => aiur_fn_610(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_611] = []; + record.function_queries[611].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_605] = []; - record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_611] = []; + record.function_queries[611].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -51518,24 +52821,24 @@ fn aiur_fn_605( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_11, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[768].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i)?; } record.function_queries[768].output_at(__i).to_array::() }, _ => aiur_fn_768(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_30, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_30, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[607].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i)?; } record.function_queries[607].output_at(__i).to_array::() }, _ => aiur_fn_607(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_605] = []; - record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[612].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i)?; } record.function_queries[612].output_at(__i).to_array::() }, _ => aiur_fn_612(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_611] = []; + record.function_queries[611].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -51556,34 +52859,35 @@ fn aiur_fn_605( }) } -const INPUT_SIZE_606: usize = 7; -const IN_606: usize = 7; -const OUT_606: usize = 0; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_612: usize = 7; +const IN_612: usize = 7; +const OUT_612: usize = 0; +fn aiur_fn_612( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], ExecError> { +) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(612); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_606] = []; - record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_612] = []; + record.function_queries[612].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -51600,23 +52904,23 @@ fn aiur_fn_606( 6u64 => { let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_11, __v_5, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[608].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i)?; } record.function_queries[608].output_at(__i).to_array::() }, _ => aiur_fn_608(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_24, __v_6, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[373].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i)?; } record.function_queries[373].output_at(__i).to_array::() }, _ => aiur_fn_373(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_27, __v_3, __v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[613].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i)?; } record.function_queries[613].output_at(__i).to_array::() }, _ => aiur_fn_613(__key, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_606] = []; - record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[612].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i)?; } record.function_queries[612].output_at(__i).to_array::() }, _ => aiur_fn_612(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_612] = []; + record.function_queries[612].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -51628,137 +52932,141 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 4; -const IN_607: usize = 4; -const OUT_607: usize = 0; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_613: usize = 4; +const IN_613: usize = 4; +const OUT_613: usize = 0; +fn aiur_fn_613( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], ExecError> { +) -> Result<[G; OUT_613], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(613); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[611].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i)?; } record.function_queries[611].output_at(__i).to_array::() }, _ => aiur_fn_611(__key, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_607] = []; - record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_6, __v_1, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[613].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i)?; } record.function_queries[613].output_at(__i).to_array::() }, _ => aiur_fn_613(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + record.function_queries[613].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_607] = []; - record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_613] = []; + record.function_queries[613].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_608: usize = 4; -const IN_608: usize = 4; -const OUT_608: usize = 0; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_614: usize = 4; +const IN_614: usize = 4; +const OUT_614: usize = 0; +fn aiur_fn_614( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], ExecError> { +) -> Result<[G; OUT_614], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(614); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[608].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i)?; } record.function_queries[608].output_at(__i).to_array::() }, _ => aiur_fn_608(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_608] = []; - record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_9, __v_8, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[613].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i)?; } record.function_queries[613].output_at(__i).to_array::() }, _ => aiur_fn_613(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_614] = []; + record.function_queries[614].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_609: usize = 8; -const IN_609: usize = 8; -const OUT_609: usize = 0; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_615: usize = 8; +const IN_615: usize = 8; +const OUT_615: usize = 0; +fn aiur_fn_615( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], ExecError> { +) -> Result<[G; OUT_615], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(615); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = (__v_1 + __v_2); let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_0, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_609] = []; - record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[616].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i)?; } record.function_queries[616].output_at(__i).to_array::() }, _ => aiur_fn_616(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_615] = []; + record.function_queries[615].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_610: usize = 10; -const IN_610: usize = 10; -const OUT_610: usize = 0; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_616: usize = 10; +const IN_616: usize = 10; +const OUT_616: usize = 0; +fn aiur_fn_616( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_610], ExecError> { +) -> Result<[G; OUT_616], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(616); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; let __v_10: G = (__v_3 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_610] = []; - record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_616] = []; + record.function_queries[616].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -51773,15 +53081,15 @@ fn aiur_fn_610( let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_0, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[598].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i)?; } record.function_queries[598].output_at(__i).to_array::() }, _ => aiur_fn_598(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[596].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i)?; } record.function_queries[596].output_at(__i).to_array::() }, _ => aiur_fn_596(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_14, __v_18, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[602].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i)?; } record.function_queries[602].output_at(__i).to_array::() }, _ => aiur_fn_602(__key, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_14, __v_18, __v_5, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[614].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i)?; } record.function_queries[614].output_at(__i).to_array::() }, _ => aiur_fn_614(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -51789,7 +53097,7 @@ fn aiur_fn_610( }, } }; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_15, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { @@ -51806,9 +53114,9 @@ fn aiur_fn_610( } let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_610] = []; - record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[616].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i)?; } record.function_queries[616].output_at(__i).to_array::() }, _ => aiur_fn_616(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_616] = []; + record.function_queries[616].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -51820,79 +53128,81 @@ fn aiur_fn_610( }) } -const INPUT_SIZE_611: usize = 12; -const IN_611: usize = 12; -const OUT_611: usize = 0; -fn aiur_fn_611( - inp: [G; IN_611], +const INPUT_SIZE_617: usize = 12; +const IN_617: usize = 12; +const OUT_617: usize = 0; +fn aiur_fn_617( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_611], ExecError> { +) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(617); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_611] = []; - record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[615].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i)?; } record.function_queries[615].output_at(__i).to_array::() }, _ => aiur_fn_615(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_617] = []; + record.function_queries[617].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_611] = []; - record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_617] = []; + record.function_queries[617].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_612: usize = 13; -const IN_612: usize = 13; -const OUT_612: usize = 0; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_618: usize = 13; +const IN_618: usize = 13; +const OUT_618: usize = 0; +fn aiur_fn_618( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], ExecError> { +) -> Result<[G; OUT_618], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - 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]; + record.checkpoint(618); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_612] = []; - record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_618] = []; + record.function_queries[618].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -51946,14 +53256,14 @@ fn aiur_fn_612( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_612] = []; - record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[619].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i)?; } record.function_queries[619].output_at(__i).to_array::() }, _ => aiur_fn_619(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_618] = []; + record.function_queries[618].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_612] = []; - record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_618] = []; + record.function_queries[618].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -51963,32 +53273,33 @@ fn aiur_fn_612( } }, _ => { - let __ret: [G; OUT_612] = []; - record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_618] = []; + record.function_queries[618].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_613: usize = 7; -const IN_613: usize = 7; -const OUT_613: usize = 0; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_619: usize = 7; +const IN_619: usize = 7; +const OUT_619: usize = 0; +fn aiur_fn_619( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_613], ExecError> { +) -> Result<[G; OUT_619], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(619); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -52038,8 +53349,8 @@ fn aiur_fn_613( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_613] = []; - record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_619] = []; + record.function_queries[619].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -52051,15 +53362,15 @@ fn aiur_fn_613( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[619].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i)?; } record.function_queries[619].output_at(__i).to_array::() }, _ => aiur_fn_619(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_619] = []; + record.function_queries[619].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_6, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[291].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i)?; } record.function_queries[291].output_at(__i).to_array::() }, _ => aiur_fn_291(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_57: G = __loaded[0]; let __v_58: G = __loaded[1]; let __v_59: G = __loaded[2]; @@ -52074,23 +53385,23 @@ fn aiur_fn_613( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_59, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[598].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i)?; } record.function_queries[598].output_at(__i).to_array::() }, _ => aiur_fn_598(__key, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_1, __v_69, __v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); - let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_59, __v_74, __v_77]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_73, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_73, __v_78]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -52098,17 +53409,17 @@ fn aiur_fn_613( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[619].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i)?; } record.function_queries[619].output_at(__i).to_array::() }, _ => aiur_fn_619(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_619] = []; + record.function_queries[619].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[619].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i)?; } record.function_queries[619].output_at(__i).to_array::() }, _ => aiur_fn_619(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_619] = []; + record.function_queries[619].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52118,9 +53429,9 @@ fn aiur_fn_613( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_613] = []; - record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[619].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i)?; } record.function_queries[619].output_at(__i).to_array::() }, _ => aiur_fn_619(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_619] = []; + record.function_queries[619].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52132,63 +53443,64 @@ fn aiur_fn_613( }) } -const INPUT_SIZE_614: usize = 16; -const IN_614: usize = 16; -const OUT_614: usize = 1; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_620: usize = 16; +const IN_620: usize = 16; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_614], ExecError> { +) -> Result<[G; OUT_620], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __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 __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } }; + record.checkpoint(620); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[299].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i)?; } record.function_queries[299].output_at(__i).to_array::() }, _ => aiur_fn_299(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -52197,26 +53509,26 @@ fn aiur_fn_614( match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); - let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_5, __v_9, __v_10, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[621].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i)?; } record.function_queries[621].output_at(__i).to_array::() }, _ => aiur_fn_621(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_614] = [__v_20]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_20]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52225,8 +53537,8 @@ fn aiur_fn_614( }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_17]; - record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_620] = [__v_17]; + record.function_queries[620].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52237,34 +53549,35 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 4; -const IN_615: usize = 4; -const OUT_615: usize = 1; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_621: usize = 4; +const IN_621: usize = 4; +const OUT_621: usize = 1; +fn aiur_fn_621( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], ExecError> { +) -> Result<[G; OUT_621], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(621); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[622].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i)?; } record.function_queries[622].output_at(__i).to_array::() }, _ => aiur_fn_622(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_8]; - record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_621] = [__v_8]; + record.function_queries[621].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -52272,19 +53585,19 @@ fn aiur_fn_615( match __v_4.as_canonical_u64() { 5u64 => { let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_6, __v_11, __v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[621].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i)?; } record.function_queries[621].output_at(__i).to_array::() }, _ => aiur_fn_621(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_615] = [__v_12]; - record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_621] = [__v_12]; + record.function_queries[621].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_8]; - record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_621] = [__v_8]; + record.function_queries[621].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52293,48 +53606,49 @@ fn aiur_fn_615( }) } -const INPUT_SIZE_616: usize = 5; -const IN_616: usize = 5; -const OUT_616: usize = 1; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_622: usize = 5; +const IN_622: usize = 5; +const OUT_622: usize = 1; +fn aiur_fn_622( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], ExecError> { +) -> Result<[G; OUT_622], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(622); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = (__v_1 - __v_2); match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[623].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i)?; } record.function_queries[623].output_at(__i).to_array::() }, _ => aiur_fn_623(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_8]; - record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_622] = [__v_8]; + record.function_queries[622].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_7, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_10, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -52346,26 +53660,26 @@ fn aiur_fn_616( }, _ => { let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_20, __v_19, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_21]; }, } }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[622].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i)?; } record.function_queries[622].output_at(__i).to_array::() }, _ => aiur_fn_622(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_616] = [__v_25]; - record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_622] = [__v_25]; + record.function_queries[622].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_616] = [__v_10]; - record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_622] = [__v_10]; + record.function_queries[622].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52374,44 +53688,45 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 2; -const IN_617: usize = 2; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_623: usize = 2; +const IN_623: usize = 2; +const OUT_623: usize = 1; +fn aiur_fn_623( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_617], ExecError> { +) -> Result<[G; OUT_623], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(623); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_617] = [__v_5]; - record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_623] = [__v_5]; + record.function_queries[623].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[624].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i)?; } record.function_queries[624].output_at(__i).to_array::() }, _ => aiur_fn_624(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_617] = [__v_6]; - record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_623] = [__v_6]; + record.function_queries[623].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[623].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i)?; } record.function_queries[623].output_at(__i).to_array::() }, _ => aiur_fn_623(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_617] = [__v_6]; - record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_623] = [__v_6]; + record.function_queries[623].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52423,31 +53738,32 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 2; -const IN_618: usize = 2; -const OUT_618: usize = 1; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_624: usize = 2; +const IN_624: usize = 2; +const OUT_624: usize = 1; +fn aiur_fn_624( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_618], ExecError> { +) -> Result<[G; OUT_624], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(624); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_618] = [__v_5]; - record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_624] = [__v_5]; + record.function_queries[624].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -52458,24 +53774,24 @@ fn aiur_fn_618( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_618] = [__v_10]; - record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_624] = [__v_10]; + record.function_queries[624].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[624].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i)?; } record.function_queries[624].output_at(__i).to_array::() }, _ => aiur_fn_624(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_10]; - record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_624] = [__v_10]; + record.function_queries[624].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[624].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i)?; } record.function_queries[624].output_at(__i).to_array::() }, _ => aiur_fn_624(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_9]; - record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_624] = [__v_9]; + record.function_queries[624].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52487,66 +53803,67 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 13; -const IN_619: usize = 13; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_625: usize = 13; +const IN_625: usize = 13; +const OUT_625: usize = 1; +fn aiur_fn_625( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], ExecError> { +) -> Result<[G; OUT_625], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(625); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[626].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i)?; } record.function_queries[626].output_at(__i).to_array::() }, _ => aiur_fn_626(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_14]; - record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_625] = [__v_14]; + record.function_queries[625].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = (__v_3 + __v_4); let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_14, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_18, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_23]; - record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_625] = [__v_23]; + record.function_queries[625].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_7, __v_8, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -52562,22 +53879,22 @@ fn aiur_fn_619( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_619] = [__v_37]; - record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_625] = [__v_37]; + record.function_queries[625].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_37]; - record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_625] = [__v_37]; + record.function_queries[625].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_23]; - record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_625] = [__v_23]; + record.function_queries[625].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52588,37 +53905,38 @@ fn aiur_fn_619( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_619] = [__v_13]; - record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_625] = [__v_13]; + record.function_queries[625].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_620: usize = 2; -const IN_620: usize = 2; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_626: usize = 2; +const IN_626: usize = 2; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_620], ExecError> { +) -> Result<[G; OUT_626], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + record.checkpoint(626); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_620] = [__v_3]; - record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_626] = [__v_3]; + record.function_queries[626].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -52672,16 +53990,16 @@ fn aiur_fn_620( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[628].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[628].bump_multiplicity(__i)?; } record.function_queries[628].output_at(__i).to_array::() }, _ => aiur_fn_628(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_52]; - record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_626] = [__v_52]; + record.function_queries[626].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_620] = [__v_51]; - record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_626] = [__v_51]; + record.function_queries[626].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52692,18 +54010,19 @@ fn aiur_fn_620( }) } -const INPUT_SIZE_621: usize = 1; -const IN_621: usize = 1; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_627: usize = 1; +const IN_627: usize = 1; +const OUT_627: usize = 1; +fn aiur_fn_627( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_621], ExecError> { +) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(627); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -52757,14 +54076,14 @@ fn aiur_fn_621( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_621] = [__v_49]; - record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_627] = [__v_49]; + record.function_queries[627].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_621] = [__v_49]; - record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_627] = [__v_49]; + record.function_queries[627].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52773,19 +54092,20 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 2; -const IN_622: usize = 2; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_628: usize = 2; +const IN_628: usize = 2; +const OUT_628: usize = 1; +fn aiur_fn_628( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_622], ExecError> { +) -> Result<[G; OUT_628], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(628); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -52838,14 +54158,14 @@ fn aiur_fn_622( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_622] = [__v_49]; - record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_628] = [__v_49]; + record.function_queries[628].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_622] = [__v_49]; - record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_628] = [__v_49]; + record.function_queries[628].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52855,17 +54175,17 @@ fn aiur_fn_622( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_48, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[628].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[628].bump_multiplicity(__i)?; } record.function_queries[628].output_at(__i).to_array::() }, _ => aiur_fn_628(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_51]; - record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_628] = [__v_51]; + record.function_queries[628].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_48, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[628].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[628].bump_multiplicity(__i)?; } record.function_queries[628].output_at(__i).to_array::() }, _ => aiur_fn_628(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_49]; - record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_628] = [__v_49]; + record.function_queries[628].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52877,45 +54197,46 @@ fn aiur_fn_622( }) } -const INPUT_SIZE_623: usize = 5; -const IN_623: usize = 5; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_629: usize = 5; +const IN_629: usize = 5; +const OUT_629: usize = 1; +fn aiur_fn_629( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_623], ExecError> { +) -> Result<[G; OUT_629], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(629); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_623] = [__v_16]; - record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_629] = [__v_16]; + record.function_queries[629].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -52930,62 +54251,63 @@ fn aiur_fn_623( }) } -const INPUT_SIZE_624: usize = 12; -const IN_624: usize = 12; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_630: usize = 12; +const IN_630: usize = 12; +const OUT_630: usize = 1; +fn aiur_fn_630( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], ExecError> { +) -> Result<[G; OUT_630], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(630); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; match __v_0.as_canonical_u64() { 7u64 => { let __v_12: G = (__v_3 + __v_5); let __v_13: G = (__v_12 + __v_6); let __v_14: G = (__v_13 + __v_4); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; let __v_19: G = __loaded[3]; match __v_16.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_624] = [__v_24]; - record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_630] = [__v_24]; + record.function_queries[630].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_28]; - record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_630] = [__v_28]; + record.function_queries[630].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -52993,9 +54315,9 @@ fn aiur_fn_624( _ => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_22]; - record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_630] = [__v_22]; + record.function_queries[630].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53003,54 +54325,55 @@ fn aiur_fn_624( _ => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_14]; - record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_630] = [__v_14]; + record.function_queries[630].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_625: usize = 6; -const IN_625: usize = 6; -const OUT_625: usize = 1; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_631: usize = 6; +const IN_631: usize = 6; +const OUT_631: usize = 1; +fn aiur_fn_631( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], ExecError> { +) -> Result<[G; OUT_631], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(631); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_15, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_15, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_16, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_16, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[632].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i)?; } record.function_queries[632].output_at(__i).to_array::() }, _ => aiur_fn_632(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_625] = [__v_19]; - record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_631] = [__v_19]; + record.function_queries[631].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -53060,19 +54383,20 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 2; -const IN_626: usize = 2; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_632: usize = 2; +const IN_632: usize = 2; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_626], ExecError> { +) -> Result<[G; OUT_632], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(632); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -53080,14 +54404,14 @@ fn aiur_fn_626( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_7]; - record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_632] = [__v_7]; + record.function_queries[632].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_3, __v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[348].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i)?; } record.function_queries[348].output_at(__i).to_array::() }, _ => aiur_fn_348(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -53095,13 +54419,13 @@ fn aiur_fn_626( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[364].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i)?; } record.function_queries[364].output_at(__i).to_array::() }, _ => aiur_fn_364(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[632].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i)?; } record.function_queries[632].output_at(__i).to_array::() }, _ => aiur_fn_632(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_12]; - record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_632] = [__v_12]; + record.function_queries[632].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -53111,27 +54435,28 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 3; -const IN_627: usize = 3; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_633: usize = 3; +const IN_633: usize = 3; +const OUT_633: usize = 1; +fn aiur_fn_633( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_627], ExecError> { +) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(633); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_6]; - record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_633] = [__v_6]; + record.function_queries[633].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -53139,33 +54464,34 @@ fn aiur_fn_627( let __v_5: G = G::from_u64(4); let __v_6: G = (__v_0 + __v_2); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0, __v_1, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[633].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i)?; } record.function_queries[633].output_at(__i).to_array::() }, _ => aiur_fn_633(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_627] = [__v_12]; - record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_633] = [__v_12]; + record.function_queries[633].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_628: usize = 2; -const IN_628: usize = 2; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +const INPUT_SIZE_634: usize = 2; +const IN_634: usize = 2; +const OUT_634: usize = 1; +fn aiur_fn_634( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_628], ExecError> { +) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(634); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -53219,16 +54545,16 @@ fn aiur_fn_628( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[635].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[635].bump_multiplicity(__i)?; } record.function_queries[635].output_at(__i).to_array::() }, _ => aiur_fn_635(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_51]; - record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_634] = [__v_51]; + record.function_queries[634].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; @@ -53244,27 +54570,27 @@ fn aiur_fn_628( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_1, __v_52, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[633].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i)?; } record.function_queries[633].output_at(__i).to_array::() }, _ => aiur_fn_633(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(1); - let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); - let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_73]; - record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained); + let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_634] = [__v_73]; + record.function_queries[634].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); - let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_628] = [__v_65]; - record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained); + let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_634] = [__v_65]; + record.function_queries[634].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53275,22 +54601,23 @@ fn aiur_fn_628( }) } -const INPUT_SIZE_629: usize = 5; -const IN_629: usize = 5; -const OUT_629: usize = 1; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_635: usize = 5; +const IN_635: usize = 5; +const OUT_635: usize = 1; +fn aiur_fn_635( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], ExecError> { +) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(635); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -53342,19 +54669,19 @@ fn aiur_fn_629( 1u64 => { let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_54]; - record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained); + let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_635] = [__v_54]; + record.function_queries[635].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[296].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i)?; } record.function_queries[296].output_at(__i).to_array::() }, _ => aiur_fn_296(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[291].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i)?; } record.function_queries[291].output_at(__i).to_array::() }, _ => aiur_fn_291(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_54: G = __loaded[0]; let __v_55: G = __loaded[1]; let __v_56: G = __loaded[2]; @@ -53379,29 +54706,29 @@ fn aiur_fn_629( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_3, __v_66, __v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[633].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i)?; } record.function_queries[633].output_at(__i).to_array::() }, _ => aiur_fn_633(__key, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); - let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[635].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[635].bump_multiplicity(__i)?; } record.function_queries[635].output_at(__i).to_array::() }, _ => aiur_fn_635(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_629] = [__v_77]; - record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained); + let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_635] = [__v_77]; + record.function_queries[635].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[635].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[635].bump_multiplicity(__i)?; } record.function_queries[635].output_at(__i).to_array::() }, _ => aiur_fn_635(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_54]; - record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_635] = [__v_54]; + record.function_queries[635].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53413,20 +54740,21 @@ fn aiur_fn_629( }) } -const INPUT_SIZE_630: usize = 3; -const IN_630: usize = 3; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 1; +fn aiur_fn_636( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_630], ExecError> { +) -> Result<[G; OUT_636], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(636); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -53436,49 +54764,49 @@ fn aiur_fn_630( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_630] = [__v_9]; - record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_636] = [__v_9]; + record.function_queries[636].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[639].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i)?; } record.function_queries[639].output_at(__i).to_array::() }, _ => aiur_fn_639(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_630] = [__v_11]; - record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_636] = [__v_11]; + record.function_queries[636].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[636].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i)?; } record.function_queries[636].output_at(__i).to_array::() }, _ => aiur_fn_636(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_11]; - record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_636] = [__v_11]; + record.function_queries[636].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[636].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i)?; } record.function_queries[636].output_at(__i).to_array::() }, _ => aiur_fn_636(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_10]; - record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_636] = [__v_10]; + record.function_queries[636].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[636].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i)?; } record.function_queries[636].output_at(__i).to_array::() }, _ => aiur_fn_636(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_9]; - record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_636] = [__v_9]; + record.function_queries[636].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53490,35 +54818,36 @@ fn aiur_fn_630( }) } -const INPUT_SIZE_631: usize = 2; -const IN_631: usize = 2; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_637: usize = 2; +const IN_637: usize = 2; +const OUT_637: usize = 1; +fn aiur_fn_637( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_631], ExecError> { +) -> Result<[G; OUT_637], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(637); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_3]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_3]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -53529,293 +54858,293 @@ fn aiur_fn_631( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 1u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[638].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i)?; } record.function_queries[638].output_at(__i).to_array::() }, _ => aiur_fn_638(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 3u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 4u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 5u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 6u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_13]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_13]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_13]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_13]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 7u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_4, __v_5, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[342].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[342].bump_multiplicity(__i)?; } record.function_queries[342].output_at(__i).to_array::() }, _ => aiur_fn_342(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 8u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_13]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_13]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_13]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_13]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_12]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_12]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_631] = [__v_11]; - record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_637] = [__v_11]; + record.function_queries[637].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53829,70 +55158,71 @@ fn aiur_fn_631( }) } -const INPUT_SIZE_632: usize = 2; -const IN_632: usize = 2; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_638: usize = 2; +const IN_638: usize = 2; +const OUT_638: usize = 1; +fn aiur_fn_638( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], ExecError> { +) -> Result<[G; OUT_638], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(638); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_632] = [__v_8]; - record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_638] = [__v_8]; + record.function_queries[638].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_8]; - record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_638] = [__v_8]; + record.function_queries[638].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_8]; - record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_638] = [__v_8]; + record.function_queries[638].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[329].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i)?; } record.function_queries[329].output_at(__i).to_array::() }, _ => aiur_fn_329(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[638].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i)?; } record.function_queries[638].output_at(__i).to_array::() }, _ => aiur_fn_638(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_632] = [__v_9]; - record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_638] = [__v_9]; + record.function_queries[638].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_632] = [__v_9]; - record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_638] = [__v_9]; + record.function_queries[638].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53909,70 +55239,71 @@ fn aiur_fn_632( }) } -const INPUT_SIZE_633: usize = 2; -const IN_633: usize = 2; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_639: usize = 2; +const IN_639: usize = 2; +const OUT_639: usize = 1; +fn aiur_fn_639( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], ExecError> { +) -> Result<[G; OUT_639], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(639); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_633] = [__v_8]; - record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_639] = [__v_8]; + record.function_queries[639].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_8]; - record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_639] = [__v_8]; + record.function_queries[639].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_8]; - record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_639] = [__v_8]; + record.function_queries[639].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[639].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i)?; } record.function_queries[639].output_at(__i).to_array::() }, _ => aiur_fn_639(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_9]; - record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_639] = [__v_9]; + record.function_queries[639].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_633] = [__v_9]; - record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_639] = [__v_9]; + record.function_queries[639].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -53989,62 +55320,64 @@ fn aiur_fn_633( }) } -const INPUT_SIZE_634: usize = 13; -const IN_634: usize = 13; -const OUT_634: usize = 1; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_640: usize = 13; +const IN_640: usize = 13; +const OUT_640: usize = 1; +fn aiur_fn_640( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], ExecError> { +) -> Result<[G; OUT_640], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(640); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[631].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i)?; } record.function_queries[631].output_at(__i).to_array::() }, _ => aiur_fn_631(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_13]; - record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_640] = [__v_13]; + record.function_queries[640].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_634] = [__v_15]; - record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_640] = [__v_15]; + record.function_queries[640].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_635: usize = 2; -const IN_635: usize = 2; -const OUT_635: usize = 1; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_641: usize = 2; +const IN_641: usize = 2; +const OUT_641: usize = 1; +fn aiur_fn_641( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_635], ExecError> { +) -> Result<[G; OUT_641], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(641); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -54098,15 +55431,15 @@ fn aiur_fn_635( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[642].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i)?; } record.function_queries[642].output_at(__i).to_array::() }, _ => aiur_fn_642(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_635] = [__v_51]; - record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_641] = [__v_51]; + record.function_queries[641].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_635] = [__v_1]; - record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_641] = [__v_1]; + record.function_queries[641].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54115,22 +55448,23 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 5; -const IN_636: usize = 5; -const OUT_636: usize = 1; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_642: usize = 5; +const IN_642: usize = 5; +const OUT_642: usize = 1; +fn aiur_fn_642( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], ExecError> { +) -> Result<[G; OUT_642], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(642); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -54180,18 +55514,18 @@ fn aiur_fn_636( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_636] = [__v_4]; - record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_642] = [__v_4]; + record.function_queries[642].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[296].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i)?; } record.function_queries[296].output_at(__i).to_array::() }, _ => aiur_fn_296(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_52]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_54: G = __loaded[0]; let __v_55: G = __loaded[1]; let __v_56: G = __loaded[2]; @@ -54206,11 +55540,11 @@ fn aiur_fn_636( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_66]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_66]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_68: G = __loaded[0]; let __v_69: G = __loaded[1]; let __v_70: G = __loaded[2]; @@ -54225,20 +55559,20 @@ fn aiur_fn_636( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_636] = [__v_75]; - record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_642] = [__v_75]; + record.function_queries[642].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_636] = [__v_4]; - record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_642] = [__v_4]; + record.function_queries[642].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_636] = [__v_4]; - record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_642] = [__v_4]; + record.function_queries[642].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54246,10 +55580,10 @@ fn aiur_fn_636( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[642].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i)?; } record.function_queries[642].output_at(__i).to_array::() }, _ => aiur_fn_642(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_636] = [__v_54]; - record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_642] = [__v_54]; + record.function_queries[642].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54261,20 +55595,21 @@ fn aiur_fn_636( }) } -const INPUT_SIZE_637: usize = 3; -const IN_637: usize = 3; -const OUT_637: usize = 1; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_643: usize = 3; +const IN_643: usize = 3; +const OUT_643: usize = 1; +fn aiur_fn_643( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], ExecError> { +) -> Result<[G; OUT_643], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(643); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -54328,7 +55663,7 @@ fn aiur_fn_637( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[642].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i)?; } record.function_queries[642].output_at(__i).to_array::() }, _ => aiur_fn_642(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, @@ -54340,7 +55675,7 @@ fn aiur_fn_637( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -54394,14 +55729,14 @@ fn aiur_fn_637( match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[635].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[635].bump_multiplicity(__i)?; } record.function_queries[635].output_at(__i).to_array::() }, _ => aiur_fn_635(__key, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_101: G = __loaded[0]; let __v_102: G = __loaded[1]; let __v_103: G = __loaded[2]; @@ -54417,23 +55752,23 @@ fn aiur_fn_637( match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_2, __v_102, __v_113]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[633].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i)?; } record.function_queries[633].output_at(__i).to_array::() }, _ => aiur_fn_633(__key, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); let __v_117: G = G::from_u64(1); let __v_118: G = G::from_u64(1); - let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_119: G = { let __values: [G; 3] = [__v_117, __v_118, __v_118]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_120: G = G::from_u64(1); let __v_121: G = G::from_u64(1); - let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_122: G = { let __values: [G; 6] = [__v_120, __v_121, __v_121, __v_121, __v_121, __v_121]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_123: G = { let __values: [G; 6] = [__v_115, __v_51, __v_116, __v_119, __v_114, __v_122]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_1 [__v_123]; }, _ => { let __v_113: G = G::from_u64(1); let __v_114: G = G::from_u64(1); - let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_115: G = { let __values: [G; 6] = [__v_113, __v_114, __v_114, __v_114, __v_114, __v_114]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_1 [__v_115]; }, } @@ -54443,40 +55778,41 @@ fn aiur_fn_637( } }; let __v_100: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[627].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i)?; } record.function_queries[627].output_at(__i).to_array::() }, _ => aiur_fn_627(__key, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_637] = [__v_100]; - record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_643] = [__v_100]; + record.function_queries[643].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_0, __v_51, __v_2, __v_100]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[644].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i)?; } record.function_queries[644].output_at(__i).to_array::() }, _ => aiur_fn_644(__key, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __ret: [G; OUT_637] = [__v_102]; - record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_643] = [__v_102]; + record.function_queries[643].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_638: usize = 4; -const IN_638: usize = 4; -const OUT_638: usize = 1; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_644: usize = 4; +const IN_644: usize = 4; +const OUT_644: usize = 1; +fn aiur_fn_644( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], ExecError> { +) -> Result<[G; OUT_644], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(644); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -54530,15 +55866,15 @@ fn aiur_fn_638( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[645].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i)?; } record.function_queries[645].output_at(__i).to_array::() }, _ => aiur_fn_645(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_638] = [__v_53]; - record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_644] = [__v_53]; + record.function_queries[644].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_638] = [__v_3]; - record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_644] = [__v_3]; + record.function_queries[644].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54547,24 +55883,25 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 7; -const IN_639: usize = 7; -const OUT_639: usize = 1; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_645: usize = 7; +const IN_645: usize = 7; +const OUT_645: usize = 1; +fn aiur_fn_645( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_639], ExecError> { +) -> Result<[G; OUT_645], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(645); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -54614,18 +55951,18 @@ fn aiur_fn_639( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_639] = [__v_5]; - record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_645] = [__v_5]; + record.function_queries[645].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[296].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i)?; } record.function_queries[296].output_at(__i).to_array::() }, _ => aiur_fn_296(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_54]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_56: G = __loaded[0]; let __v_57: G = __loaded[1]; let __v_58: G = __loaded[2]; @@ -54640,11 +55977,11 @@ fn aiur_fn_639( let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_68]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_68]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; @@ -54659,7 +55996,7 @@ fn aiur_fn_639( let __v_81: G = __loaded[11]; match __v_70.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_77, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; match __v_82.as_canonical_u64() { 1u64 => { @@ -54701,39 +56038,39 @@ fn aiur_fn_639( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[645].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i)?; } record.function_queries[645].output_at(__i).to_array::() }, _ => aiur_fn_645(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_75]; - record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_645] = [__v_75]; + record.function_queries[645].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[640].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i)?; } record.function_queries[640].output_at(__i).to_array::() }, _ => aiur_fn_640(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[630].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i)?; } record.function_queries[630].output_at(__i).to_array::() }, _ => aiur_fn_630(__key, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_69, __v_73]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[636].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i)?; } record.function_queries[636].output_at(__i).to_array::() }, _ => aiur_fn_636(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = (__v_6 + __v_76); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[645].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i)?; } record.function_queries[645].output_at(__i).to_array::() }, _ => aiur_fn_645(__key, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_78]; - record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_645] = [__v_78]; + record.function_queries[645].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[779].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i)?; } record.function_queries[779].output_at(__i).to_array::() }, _ => aiur_fn_779(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_6 + __v_78); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[645].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i)?; } record.function_queries[645].output_at(__i).to_array::() }, _ => aiur_fn_645(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_80]; - record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_645] = [__v_80]; + record.function_queries[645].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54743,10 +56080,10 @@ fn aiur_fn_639( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[645].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i)?; } record.function_queries[645].output_at(__i).to_array::() }, _ => aiur_fn_645(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_639] = [__v_56]; - record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_645] = [__v_56]; + record.function_queries[645].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54758,20 +56095,21 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 3; -const IN_640: usize = 3; -const OUT_640: usize = 2; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_646: usize = 3; +const IN_646: usize = 3; +const OUT_646: usize = 2; +fn aiur_fn_646( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_640], ExecError> { +) -> Result<[G; OUT_646], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(646); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -54782,28 +56120,28 @@ fn aiur_fn_640( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_640] = [__v_9, __v_10]; - record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_646] = [__v_9, __v_10]; + record.function_queries[646].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_640] = [__v_10, __v_2]; - record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_646] = [__v_10, __v_2]; + record.function_queries[646].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[646].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i)?; } record.function_queries[646].output_at(__i).to_array::() }, _ => aiur_fn_646(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_640] = [__v_12, __v_13]; - record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_646] = [__v_12, __v_13]; + record.function_queries[646].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54815,22 +56153,23 @@ fn aiur_fn_640( }) } -const INPUT_SIZE_641: usize = 5; -const IN_641: usize = 5; -const OUT_641: usize = 2; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_647: usize = 5; +const IN_647: usize = 5; +const OUT_647: usize = 2; +fn aiur_fn_647( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], ExecError> { +) -> Result<[G; OUT_647], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(647); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -54841,12 +56180,12 @@ fn aiur_fn_641( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_641] = [__v_11, __v_12]; - record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_647] = [__v_11, __v_12]; + record.function_queries[647].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_2 - __v_7); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_12.as_canonical_u64() { @@ -54863,7 +56202,7 @@ fn aiur_fn_641( let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[639].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i)?; } record.function_queries[639].output_at(__i).to_array::() }, _ => aiur_fn_639(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -54879,18 +56218,18 @@ fn aiur_fn_641( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_641] = [__v_17, __v_4]; - record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_647] = [__v_17, __v_4]; + record.function_queries[647].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[647].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i)?; } record.function_queries[647].output_at(__i).to_array::() }, _ => aiur_fn_647(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_641] = [__v_19, __v_20]; - record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_647] = [__v_19, __v_20]; + record.function_queries[647].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54902,19 +56241,20 @@ fn aiur_fn_641( }) } -const INPUT_SIZE_642: usize = 2; -const IN_642: usize = 2; -const OUT_642: usize = 4; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_648: usize = 2; +const IN_648: usize = 2; +const OUT_648: usize = 4; +fn aiur_fn_648( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], ExecError> { +) -> Result<[G; OUT_648], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(648); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -54955,35 +56295,35 @@ fn aiur_fn_642( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_642] = [__v_40, __v_41, __v_44, __v_47]; - record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained); + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_648] = [__v_40, __v_41, __v_44, __v_47]; + record.function_queries[648].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_642] = [__v_3, __v_4, __v_5, __v_6]; - record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_648] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[648].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[648].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i)?; } record.function_queries[648].output_at(__i).to_array::() }, _ => aiur_fn_648(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __ret: [G; OUT_642] = [__v_10, __v_11, __v_12, __v_13]; - record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_648] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[648].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -54995,20 +56335,21 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 4; -const IN_643: usize = 4; -const OUT_643: usize = 1; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_649: usize = 4; +const IN_649: usize = 4; +const OUT_649: usize = 1; +fn aiur_fn_649( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], ExecError> { +) -> Result<[G; OUT_649], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(649); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); @@ -55016,21 +56357,21 @@ fn aiur_fn_643( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_643] = [__v_9]; - record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_649] = [__v_9]; + record.function_queries[649].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_6]; - record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_649] = [__v_6]; + record.function_queries[649].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55039,9 +56380,9 @@ fn aiur_fn_643( let __v_8: G = (__v_1 - __v_7); let __v_9: G = (__v_8 - __v_0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_643] = [__v_11]; - record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_649] = [__v_11]; + record.function_queries[649].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -55050,49 +56391,50 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 6; -const IN_644: usize = 6; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_650: usize = 6; +const IN_650: usize = 6; +const OUT_650: usize = 1; +fn aiur_fn_650( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_644], ExecError> { +) -> Result<[G; OUT_650], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(650); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_644] = [__v_0]; - record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_650] = [__v_0]; + record.function_queries[650].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_5, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[649].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i)?; } record.function_queries[649].output_at(__i).to_array::() }, _ => aiur_fn_649(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_8, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_1 - __v_13); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_5 + __v_15); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[650].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i)?; } record.function_queries[650].output_at(__i).to_array::() }, _ => aiur_fn_650(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_17]; - record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_650] = [__v_17]; + record.function_queries[650].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55104,29 +56446,30 @@ fn aiur_fn_644( }) } -const INPUT_SIZE_645: usize = 2; -const IN_645: usize = 2; -const OUT_645: usize = 1; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_651: usize = 2; +const IN_651: usize = 2; +const OUT_651: usize = 1; +fn aiur_fn_651( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_645], ExecError> { +) -> Result<[G; OUT_651], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(651); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_4]; - record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_651] = [__v_4]; + record.function_queries[651].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -55136,20 +56479,20 @@ fn aiur_fn_645( let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 - __v_7); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[651].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i)?; } record.function_queries[651].output_at(__i).to_array::() }, _ => aiur_fn_651(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_10]; - record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_651] = [__v_10]; + record.function_queries[651].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -55159,19 +56502,19 @@ fn aiur_fn_645( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_1 - __v_15); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_12, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[651].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i)?; } record.function_queries[651].output_at(__i).to_array::() }, _ => aiur_fn_651(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_18]; - record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_651] = [__v_18]; + record.function_queries[651].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_16]; - record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_651] = [__v_16]; + record.function_queries[651].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -55182,25 +56525,26 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 4; -const IN_646: usize = 4; -const OUT_646: usize = 1; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_652: usize = 4; +const IN_652: usize = 4; +const OUT_652: usize = 1; +fn aiur_fn_652( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(652); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_646] = [__v_0]; - record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_652] = [__v_0]; + record.function_queries[652].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55210,56 +56554,57 @@ fn aiur_fn_646( let __v_8: G = (__v_7 - __v_3); let __v_9: G = (__v_8 + __v_2); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_14, __v_1, __v_2, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[652].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i)?; } record.function_queries[652].output_at(__i).to_array::() }, _ => aiur_fn_652(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_646] = [__v_17]; - record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_652] = [__v_17]; + record.function_queries[652].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_647: usize = 3; -const IN_647: usize = 3; -const OUT_647: usize = 1; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_653: usize = 3; +const IN_653: usize = 3; +const OUT_653: usize = 1; +fn aiur_fn_653( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], ExecError> { +) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(653); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_647] = [__v_0]; - record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_653] = [__v_0]; + record.function_queries[653].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10, __v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[653].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i)?; } record.function_queries[653].output_at(__i).to_array::() }, _ => aiur_fn_653(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_647] = [__v_11]; - record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_653] = [__v_11]; + record.function_queries[653].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55269,59 +56614,61 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 5; -const IN_648: usize = 5; -const OUT_648: usize = 1; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_654: usize = 5; +const IN_654: usize = 5; +const OUT_654: usize = 1; +fn aiur_fn_654( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], ExecError> { +) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(654); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0, __v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[652].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i)?; } record.function_queries[652].output_at(__i).to_array::() }, _ => aiur_fn_652(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_6]; - record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_654] = [__v_6]; + record.function_queries[654].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_4, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[653].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i)?; } record.function_queries[653].output_at(__i).to_array::() }, _ => aiur_fn_653(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_5]; - record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_654] = [__v_5]; + record.function_queries[654].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_649: usize = 3; -const IN_649: usize = 3; -const OUT_649: usize = 1; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_655: usize = 3; +const IN_655: usize = 3; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_649], ExecError> { +) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(655); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_649] = [__v_0]; - record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_655] = [__v_0]; + record.function_queries[655].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55330,52 +56677,53 @@ fn aiur_fn_649( let __v_6: G = (__v_1 - __v_5); let __v_7: G = (__v_6 - __v_2); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(3); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = (__v_2 + __v_13); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_12, __v_1, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[655].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i)?; } record.function_queries[655].output_at(__i).to_array::() }, _ => aiur_fn_655(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_15]; - record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_655] = [__v_15]; + record.function_queries[655].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_650: usize = 2; -const IN_650: usize = 2; -const OUT_650: usize = 1; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_656: usize = 2; +const IN_656: usize = 2; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_650], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(656); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_650] = [__v_0]; - record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_656] = [__v_0]; + record.function_queries[656].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_650] = [__v_8]; - record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_656] = [__v_8]; + record.function_queries[656].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55385,29 +56733,30 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 2; -const IN_651: usize = 2; -const OUT_651: usize = 2; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_657: usize = 2; +const IN_657: usize = 2; +const OUT_657: usize = 2; +fn aiur_fn_657( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], ExecError> { +) -> Result<[G; OUT_657], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(657); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_4, __v_0]; - record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_657] = [__v_4, __v_0]; + record.function_queries[657].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -55416,22 +56765,22 @@ fn aiur_fn_651( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i); } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[657].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i)?; } record.function_queries[657].output_at(__i).to_array::() }, _ => aiur_fn_657(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_11, __v_9]; - record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_657] = [__v_11, __v_9]; + record.function_queries[657].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -55440,21 +56789,21 @@ fn aiur_fn_651( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i); } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_12, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[657].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i)?; } record.function_queries[657].output_at(__i).to_array::() }, _ => aiur_fn_657(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_19, __v_17]; - record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained); + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_657] = [__v_19, __v_17]; + record.function_queries[657].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_651] = [__v_16, __v_0]; - record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_657] = [__v_16, __v_0]; + record.function_queries[657].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -55465,20 +56814,21 @@ fn aiur_fn_651( }) } -const INPUT_SIZE_652: usize = 3; -const IN_652: usize = 3; -const OUT_652: usize = 1; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_658: usize = 3; +const IN_658: usize = 3; +const OUT_658: usize = 1; +fn aiur_fn_658( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_658], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(658); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -55486,22 +56836,22 @@ fn aiur_fn_652( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_8]; - record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_658] = [__v_8]; + record.function_queries[658].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_5, __v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[658].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i)?; } record.function_queries[658].output_at(__i).to_array::() }, _ => aiur_fn_658(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_652] = [__v_11]; - record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_658] = [__v_11]; + record.function_queries[658].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55511,120 +56861,123 @@ fn aiur_fn_652( }) } -const INPUT_SIZE_653: usize = 6; -const IN_653: usize = 6; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_659: usize = 6; +const IN_659: usize = 6; +const OUT_659: usize = 1; +fn aiur_fn_659( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], ExecError> { +) -> Result<[G; OUT_659], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(659); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_5, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[653].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i)?; } record.function_queries[653].output_at(__i).to_array::() }, _ => aiur_fn_653(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_6]; - record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_659] = [__v_6]; + record.function_queries[659].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_2, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_7]; - record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_659] = [__v_7]; + record.function_queries[659].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_654: usize = 3; -const IN_654: usize = 3; -const OUT_654: usize = 1; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_660: usize = 3; +const IN_660: usize = 3; +const OUT_660: usize = 1; +fn aiur_fn_660( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], ExecError> { +) -> Result<[G; OUT_660], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(660); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_654] = [__v_0]; - record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_660] = [__v_0]; + record.function_queries[660].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); let __v_5: G = (__v_1 - __v_2); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_8: G = G::from_u64(3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[654].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[654].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[654].bump_multiplicity(__i); } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_10, __v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[660].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i)?; } record.function_queries[660].output_at(__i).to_array::() }, _ => aiur_fn_660(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_654] = [__v_13]; - record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_660] = [__v_13]; + record.function_queries[660].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_655: usize = 9; -const IN_655: usize = 9; -const OUT_655: usize = 1; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_661: usize = 9; +const IN_661: usize = 9; +const OUT_661: usize = 1; +fn aiur_fn_661( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], ExecError> { +) -> Result<[G; OUT_661], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + record.checkpoint(661); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[650].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i)?; } record.function_queries[650].output_at(__i).to_array::() }, _ => aiur_fn_650(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_11, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[651].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i)?; } record.function_queries[651].output_at(__i).to_array::() }, _ => aiur_fn_651(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_0, __v_4, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_15, __v_6, __v_3, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[652].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i)?; } record.function_queries[652].output_at(__i).to_array::() }, _ => aiur_fn_652(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_15, __v_8, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[653].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i)?; } record.function_queries[653].output_at(__i).to_array::() }, _ => aiur_fn_653(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -55632,115 +56985,118 @@ fn aiur_fn_655( }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_16, __v_3, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[655].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i)?; } record.function_queries[655].output_at(__i).to_array::() }, _ => aiur_fn_655(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); - let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 4] = [__v_19, __v_5, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); - let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_24, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_24, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_655] = [__v_25]; - record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_661] = [__v_25]; + record.function_queries[661].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_656: usize = 3; -const IN_656: usize = 3; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_662: usize = 3; +const IN_662: usize = 3; +const OUT_662: usize = 1; +fn aiur_fn_662( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], ExecError> { +) -> Result<[G; OUT_662], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(662); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_0, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[697].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i)?; } record.function_queries[697].output_at(__i).to_array::() }, _ => aiur_fn_697(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_656] = [__v_4]; - record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_662] = [__v_4]; + record.function_queries[662].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_657: usize = 4; -const IN_657: usize = 4; -const OUT_657: usize = 1; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_663: usize = 4; +const IN_663: usize = 4; +const OUT_663: usize = 1; +fn aiur_fn_663( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_657], ExecError> { +) -> Result<[G; OUT_663], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(663); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_657] = [__v_0]; - record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_663] = [__v_0]; + record.function_queries[663].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); let __v_6: G = (__v_2 - __v_3); let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_11, __v_1, __v_2, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_657] = [__v_14]; - record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_663] = [__v_14]; + record.function_queries[663].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_658: usize = 2; -const IN_658: usize = 2; -const OUT_658: usize = 1; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_664: usize = 2; +const IN_664: usize = 2; +const OUT_664: usize = 1; +fn aiur_fn_664( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_658], ExecError> { +) -> Result<[G; OUT_664], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(664); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_658] = [__v_0]; - record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_664] = [__v_0]; + record.function_queries[664].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[664].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[664].bump_multiplicity(__i)?; } record.function_queries[664].output_at(__i).to_array::() }, _ => aiur_fn_664(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_658] = [__v_8]; - record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_664] = [__v_8]; + record.function_queries[664].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55750,34 +57106,35 @@ fn aiur_fn_658( }) } -const INPUT_SIZE_659: usize = 9; -const IN_659: usize = 9; -const OUT_659: usize = 1; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_665: usize = 9; +const IN_665: usize = 9; +const OUT_665: usize = 1; +fn aiur_fn_665( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], ExecError> { +) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(665); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[648].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i)?; } record.function_queries[648].output_at(__i).to_array::() }, _ => aiur_fn_648(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -55792,68 +57149,69 @@ fn aiur_fn_659( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[666].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i)?; } record.function_queries[666].output_at(__i).to_array::() }, _ => aiur_fn_666(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_27]; - record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_665] = [__v_27]; + record.function_queries[665].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[666].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i)?; } record.function_queries[666].output_at(__i).to_array::() }, _ => aiur_fn_666(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_27]; - record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_665] = [__v_27]; + record.function_queries[665].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_660: usize = 11; -const IN_660: usize = 11; -const OUT_660: usize = 1; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_666: usize = 11; +const IN_666: usize = 11; +const OUT_666: usize = 1; +fn aiur_fn_666( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } }; + record.checkpoint(666); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[784].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i)?; } record.function_queries[784].output_at(__i).to_array::() }, _ => aiur_fn_784(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_7, __v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[633].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i)?; } record.function_queries[633].output_at(__i).to_array::() }, _ => aiur_fn_633(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i); } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_14, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[657].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i)?; } record.function_queries[657].output_at(__i).to_array::() }, _ => aiur_fn_657(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_8, __v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[662].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i)?; } record.function_queries[662].output_at(__i).to_array::() }, _ => aiur_fn_662(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[680].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i)?; } record.function_queries[680].output_at(__i).to_array::() }, _ => aiur_fn_680(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[648].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i)?; } record.function_queries[648].output_at(__i).to_array::() }, _ => aiur_fn_648(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -55868,20 +57226,20 @@ fn aiur_fn_660( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_27, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_27, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[650].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i)?; } record.function_queries[650].output_at(__i).to_array::() }, _ => aiur_fn_650(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_39, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_39, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[651].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i)?; } record.function_queries[651].output_at(__i).to_array::() }, _ => aiur_fn_651(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_40, __v_41, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[658].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i)?; } record.function_queries[658].output_at(__i).to_array::() }, _ => aiur_fn_658(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_20, __v_23, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_20, __v_23, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = (__v_4 + __v_11); let __v_48: G = (__v_47 + __v_19); let __v_49: G = (__v_48 + __v_5); @@ -55891,13 +57249,13 @@ fn aiur_fn_660( let __v_53: G = (__v_52 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_46, __v_22, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[653].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i)?; } record.function_queries[653].output_at(__i).to_array::() }, _ => aiur_fn_653(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; break '__mc_0 [__v_54]; }, _ => { let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_46, __v_4, __v_51, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; break '__mc_0 [__v_55]; }, @@ -55905,7 +57263,7 @@ fn aiur_fn_660( }; let __v_54: G = __mc_out___mc_0[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_54, __v_5, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[655].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i)?; } record.function_queries[655].output_at(__i).to_array::() }, _ => aiur_fn_655(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __v_58: G = (__v_49 + __v_57); @@ -55915,30 +57273,30 @@ fn aiur_fn_660( let __v_62: G = (__v_60 - __v_61); let __v_63: G = G::from_u64(0); let __v_64: G = G::from_u64(0); - let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[654].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[654].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[654].bump_multiplicity(__i); } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_65, __v_5, __v_66]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[660].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i)?; } record.function_queries[660].output_at(__i).to_array::() }, _ => aiur_fn_660(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(3); let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); let __v_71: G = G::from_u64(0); - let __v_72: G = { let __values: [G; 4] = [__v_69, __v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = { let __values: [G; 4] = [__v_69, __v_70, __v_71, __v_71]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_73: G = G::from_u64(0); - let __v_74: G = { let __values: [G; 4] = [__v_68, __v_67, __v_72, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 4] = [__v_68, __v_67, __v_72, __v_73]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_75: G = G::from_u64(5); let __v_76: G = G::from_u64(0); - let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_77, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_77, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_78, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_78, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_79, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_79, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_80, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_80, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __ret: [G; OUT_660] = [__v_81]; - record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_666] = [__v_81]; + record.function_queries[666].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -55948,42 +57306,43 @@ fn aiur_fn_660( }) } -const INPUT_SIZE_661: usize = 26; -const IN_661: usize = 26; -const OUT_661: usize = 0; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_667: usize = 26; +const IN_667: usize = 26; +const OUT_667: usize = 0; +fn aiur_fn_667( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_661], ExecError> { +) -> Result<[G; OUT_667], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; + record.checkpoint(667); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; match __v_0.as_canonical_u64() { 7u64 => { match __v_13.as_canonical_u64() { @@ -55991,9 +57350,9 @@ fn aiur_fn_661( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_20, __v_21, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; @@ -56016,9 +57375,9 @@ fn aiur_fn_661( let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_29, __v_32, __v_33, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); break '__mc_0 [__v_26, __v_27, __v_28, __v_34, __v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; @@ -56041,85 +57400,85 @@ fn aiur_fn_661( let __v_39: G = (__v_16 + __v_17); let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_15, __v_39, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_20, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[626].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i)?; } record.function_queries[626].output_at(__i).to_array::() }, _ => aiur_fn_626(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i); } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[620].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[620].bump_multiplicity(__i)?; } record.function_queries[620].output_at(__i).to_array::() }, _ => aiur_fn_620(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { let __v_46: G = G::from_u64(4); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_1 [__v_49]; }, _ => { let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_46, __v_47, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_1 [__v_48]; }, } }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_1, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[700].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i)?; } record.function_queries[700].output_at(__i).to_array::() }, _ => aiur_fn_700(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_10, __v_20, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[643].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i)?; } record.function_queries[643].output_at(__i).to_array::() }, _ => aiur_fn_643(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_49, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[674].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i)?; } record.function_queries[674].output_at(__i).to_array::() }, _ => aiur_fn_674(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_49]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[677].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i)?; } record.function_queries[677].output_at(__i).to_array::() }, _ => aiur_fn_677(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[627].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i)?; } record.function_queries[627].output_at(__i).to_array::() }, _ => aiur_fn_627(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[627].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i)?; } record.function_queries[627].output_at(__i).to_array::() }, _ => aiur_fn_627(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = (__v_54 - __v_55); let __v_57: G = (__v_53 * __v_56); let __v_58: G = (__v_52 * __v_57); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[640].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i)?; } record.function_queries[640].output_at(__i).to_array::() }, _ => aiur_fn_640(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, _ => { let __v_59: G = G::from_u64(1); let __v_60: G = G::from_u64(1); - let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_2 [__v_61]; }, } }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[647].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i)?; } record.function_queries[647].output_at(__i).to_array::() }, _ => aiur_fn_647(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[668].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i)?; } record.function_queries[668].output_at(__i).to_array::() }, _ => aiur_fn_668(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_667] = []; + record.function_queries[667].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_49, __v_25, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[646].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i)?; } record.function_queries[646].output_at(__i).to_array::() }, _ => aiur_fn_646(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_661] = []; - record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[668].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i)?; } record.function_queries[668].output_at(__i).to_array::() }, _ => aiur_fn_668(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_667] = []; + record.function_queries[667].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -56130,8 +57489,8 @@ fn aiur_fn_661( } }, _ => { - let __ret: [G; OUT_661] = []; - record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_667] = []; + record.function_queries[667].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -56143,57 +57502,58 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 18; -const IN_662: usize = 18; -const OUT_662: usize = 0; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_668: usize = 18; +const IN_668: usize = 18; +const OUT_668: usize = 0; +fn aiur_fn_668( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], ExecError> { +) -> Result<[G; OUT_668], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } }; + record.checkpoint(668); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[648].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i)?; } record.function_queries[648].output_at(__i).to_array::() }, _ => aiur_fn_648(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[659].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[659].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[659].bump_multiplicity(__i); } let __ret: [G; OUT_659] = unsafe { *(record.function_queries[659].output_at(__i).as_ptr() as *const [G; OUT_659]) }; __ret }, _ => aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[665].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i)?; } record.function_queries[665].output_at(__i).to_array::() }, _ => aiur_fn_665(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[784].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i)?; } record.function_queries[784].output_at(__i).to_array::() }, _ => aiur_fn_784(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_10, __v_5, __v_23, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[680].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i)?; } record.function_queries[680].output_at(__i).to_array::() }, _ => aiur_fn_680(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_1, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[669].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[669].bump_multiplicity(__i)?; } record.function_queries[669].output_at(__i).to_array::() }, _ => aiur_fn_669(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[664].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[664].bump_multiplicity(__i); } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_2, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[670].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i)?; } record.function_queries[670].output_at(__i).to_array::() }, _ => aiur_fn_670(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_12, __v_22, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_12, __v_22, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(1); if (__v_33 != __v_34) { @@ -56206,36 +57566,37 @@ fn aiur_fn_662( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) }); } let __v_35: G = G::from_u64(0); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_662] = []; - record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_11, __v_29, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[671].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i)?; } record.function_queries[671].output_at(__i).to_array::() }, _ => aiur_fn_671(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_668] = []; + record.function_queries[668].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_663: usize = 3; -const IN_663: usize = 3; -const OUT_663: usize = 1; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_669: usize = 3; +const IN_669: usize = 3; +const OUT_669: usize = 1; +fn aiur_fn_669( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], ExecError> { +) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(669); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = (__v_2 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_4]; - record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_669] = [__v_4]; + record.function_queries[669].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -56245,14 +57606,14 @@ fn aiur_fn_663( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_10]; - record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_669] = [__v_10]; + record.function_queries[669].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -56278,11 +57639,11 @@ fn aiur_fn_663( let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_2 + __v_24); - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9, __v_1, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[669].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[669].bump_multiplicity(__i)?; } record.function_queries[669].output_at(__i).to_array::() }, _ => aiur_fn_669(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_663] = [__v_27]; - record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_669] = [__v_27]; + record.function_queries[669].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -56294,45 +57655,46 @@ fn aiur_fn_663( }) } -const INPUT_SIZE_664: usize = 15; -const IN_664: usize = 15; -const OUT_664: usize = 1; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_670: usize = 15; +const IN_670: usize = 15; +const OUT_670: usize = 1; +fn aiur_fn_670( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], ExecError> { +) -> Result<[G; OUT_670], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(670); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; let __v_15: G = (__v_0 - __v_14); match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_18]; - record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_670] = [__v_18]; + record.function_queries[670].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2, __v_3, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -56348,24 +57710,24 @@ fn aiur_fn_664( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[673].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i)?; } record.function_queries[673].output_at(__i).to_array::() }, _ => aiur_fn_673(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[664].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[664].bump_multiplicity(__i); } let __ret: [G; OUT_664] = unsafe { *(record.function_queries[664].output_at(__i).as_ptr() as *const [G; OUT_664]) }; __ret }, _ => aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[670].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i)?; } record.function_queries[670].output_at(__i).to_array::() }, _ => aiur_fn_670(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_35]; - record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained); + let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_670] = [__v_35]; + record.function_queries[670].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_664] = [__v_31]; - record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained); + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_670] = [__v_31]; + record.function_queries[670].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -56374,26 +57736,27 @@ fn aiur_fn_664( }) } -const INPUT_SIZE_665: usize = 9; -const IN_665: usize = 9; -const OUT_665: usize = 0; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_671: usize = 9; +const IN_671: usize = 9; +const OUT_671: usize = 0; +fn aiur_fn_671( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], ExecError> { +) -> Result<[G; OUT_671], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(671); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -56401,16 +57764,16 @@ fn aiur_fn_665( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_665] = []; - record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_671] = []; + record.function_queries[671].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5, __v_6, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -56438,19 +57801,19 @@ fn aiur_fn_665( if (__v_10 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("recursor rule is out of ctor order".to_string()) }); } - let __v_27: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_27: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_665] = []; - record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_671] = []; + record.function_queries[671].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -56460,8 +57823,8 @@ fn aiur_fn_665( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_12, __v_34, __v_35, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[702].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i)?; } record.function_queries[702].output_at(__i).to_array::() }, _ => aiur_fn_702(__key, 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]; @@ -56470,8 +57833,8 @@ fn aiur_fn_665( } let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_39, __v_30, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[444].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i)?; } record.function_queries[444].output_at(__i).to_array::() }, _ => aiur_fn_444(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -56479,9 +57842,9 @@ fn aiur_fn_665( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_665] = []; - record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[671].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i)?; } record.function_queries[671].output_at(__i).to_array::() }, _ => aiur_fn_671(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_671] = []; + record.function_queries[671].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -56498,41 +57861,42 @@ fn aiur_fn_665( }) } -const INPUT_SIZE_666: usize = 12; -const IN_666: usize = 12; -const OUT_666: usize = 1; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_672: usize = 12; +const IN_672: usize = 12; +const OUT_672: usize = 1; +fn aiur_fn_672( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], ExecError> { +) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(672); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_666] = [__v_0]; - record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_672] = [__v_0]; + record.function_queries[672].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2, __v_11, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[762].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i)?; } record.function_queries[762].output_at(__i).to_array::() }, _ => aiur_fn_762(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -56566,62 +57930,62 @@ fn aiur_fn_666( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); - let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4, __v_16, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[762].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i)?; } record.function_queries[762].output_at(__i).to_array::() }, _ => aiur_fn_762(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_5, __v_16, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[762].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i)?; } record.function_queries[762].output_at(__i).to_array::() }, _ => aiur_fn_762(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_6 + __v_7); let __v_54: G = (__v_53 + __v_8); let __v_55: G = (__v_54 + __v_9); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_9 - __v_13); let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_56, __v_57, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_59, __v_60, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[686].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i)?; } record.function_queries[686].output_at(__i).to_array::() }, _ => aiur_fn_686(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); let __v_67: G = G::from_u64(0); - let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_50, __v_10, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_68, __v_6, __v_70, __v_71]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); let __v_74: G = (__v_65 - __v_73); let __v_75: G = (__v_74 - __v_6); let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_72, __v_7, __v_75, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_65 - __v_78); let __v_80: G = (__v_79 - __v_6); let __v_81: G = (__v_80 - __v_7); let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_77, __v_8, __v_81, __v_82]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); - let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_63, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_63, __v_86]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_87]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_87]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_89, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_89, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_83, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_83, __v_90]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -56629,24 +57993,24 @@ fn aiur_fn_666( let __v_95: G = (__v_94 + __v_64); let __v_96: G = G::from_u64(0); let __v_97: G = G::from_u64(0); - let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_98, __v_64, __v_99]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[655].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i)?; } record.function_queries[655].output_at(__i).to_array::() }, _ => aiur_fn_655(__key, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); - let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_103, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_103, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[664].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[664].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[664].bump_multiplicity(__i)?; } record.function_queries[664].output_at(__i).to_array::() }, _ => aiur_fn_664(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[672].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[672].bump_multiplicity(__i)?; } record.function_queries[672].output_at(__i).to_array::() }, _ => aiur_fn_672(__key, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_666] = [__v_110]; - record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_672] = [__v_110]; + record.function_queries[672].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -56656,55 +58020,56 @@ fn aiur_fn_666( }) } -const INPUT_SIZE_667: usize = 13; -const IN_667: usize = 13; -const OUT_667: usize = 1; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_673: usize = 13; +const IN_673: usize = 13; +const OUT_673: usize = 1; +fn aiur_fn_673( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], ExecError> { +) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + record.checkpoint(673); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_13, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[683].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[683].bump_multiplicity(__i)?; } record.function_queries[683].output_at(__i).to_array::() }, _ => aiur_fn_683(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[684].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i)?; } record.function_queries[684].output_at(__i).to_array::() }, _ => aiur_fn_684(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[696].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i)?; } record.function_queries[696].output_at(__i).to_array::() }, _ => aiur_fn_696(__key, 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]; @@ -56716,33 +58081,34 @@ fn aiur_fn_667( let __v_42: G = (__v_39 - __v_41); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_45, __v_16, __v_16, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[690].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i)?; } record.function_queries[690].output_at(__i).to_array::() }, _ => aiur_fn_690(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[672].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[672].bump_multiplicity(__i)?; } record.function_queries[672].output_at(__i).to_array::() }, _ => aiur_fn_672(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_667] = [__v_49]; - record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_673] = [__v_49]; + record.function_queries[673].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_668: usize = 3; -const IN_668: usize = 3; -const OUT_668: usize = 1; -fn aiur_fn_668( - inp: [G; IN_668], +const INPUT_SIZE_674: usize = 3; +const IN_674: usize = 3; +const OUT_674: usize = 1; +fn aiur_fn_674( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_668], ExecError> { +) -> Result<[G; OUT_674], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(674); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -56753,20 +58119,20 @@ fn aiur_fn_668( 1u64 => { let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_11]; - record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_674] = [__v_11]; + record.function_queries[674].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[669].bump_multiplicity(__i); } let __ret: [G; OUT_669] = unsafe { *(record.function_queries[669].output_at(__i).as_ptr() as *const [G; OUT_669]) }; __ret }, _ => aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[675].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i)?; } record.function_queries[675].output_at(__i).to_array::() }, _ => aiur_fn_675(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_8, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[674].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i)?; } record.function_queries[674].output_at(__i).to_array::() }, _ => aiur_fn_674(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_12]; - record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_674] = [__v_12]; + record.function_queries[674].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -56776,22 +58142,23 @@ fn aiur_fn_668( }) } -const INPUT_SIZE_669: usize = 5; -const IN_669: usize = 5; -const OUT_669: usize = 1; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_675: usize = 5; +const IN_675: usize = 5; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], ExecError> { +) -> Result<[G; OUT_675], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(675); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -56845,15 +58212,15 @@ fn aiur_fn_669( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[676].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i)?; } record.function_queries[676].output_at(__i).to_array::() }, _ => aiur_fn_676(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_669] = [__v_54]; - record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_675] = [__v_54]; + record.function_queries[675].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_669] = [__v_4]; - record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_675] = [__v_4]; + record.function_queries[675].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -56862,25 +58229,26 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 8; -const IN_670: usize = 8; -const OUT_670: usize = 1; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_676: usize = 8; +const IN_676: usize = 8; +const OUT_676: usize = 1; +fn aiur_fn_676( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], ExecError> { +) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(676); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -56930,18 +58298,18 @@ fn aiur_fn_670( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = [__v_6]; - record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_676] = [__v_6]; + record.function_queries[676].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[296].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i)?; } record.function_queries[296].output_at(__i).to_array::() }, _ => aiur_fn_296(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_57: G = __loaded[0]; let __v_58: G = __loaded[1]; let __v_59: G = __loaded[2]; @@ -56956,11 +58324,11 @@ fn aiur_fn_670( let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_69]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_71: G = __loaded[0]; let __v_72: G = __loaded[1]; let __v_73: G = __loaded[2]; @@ -56984,7 +58352,7 @@ fn aiur_fn_670( } }; let __v_83: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_69, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; match __v_84.as_canonical_u64() { 1u64 => { @@ -56994,9 +58362,9 @@ fn aiur_fn_670( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[631].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i)?; } record.function_queries[631].output_at(__i).to_array::() }, _ => aiur_fn_631(__key, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_85, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_85, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[639].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i)?; } record.function_queries[639].output_at(__i).to_array::() }, _ => aiur_fn_639(__key, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -57017,17 +58385,17 @@ fn aiur_fn_670( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_670] = [__v_55]; - record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_676] = [__v_55]; + record.function_queries[676].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[676].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i)?; } record.function_queries[676].output_at(__i).to_array::() }, _ => aiur_fn_676(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_72]; - record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_676] = [__v_72]; + record.function_queries[676].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -57035,10 +58403,10 @@ fn aiur_fn_670( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[676].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i)?; } record.function_queries[676].output_at(__i).to_array::() }, _ => aiur_fn_676(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_670] = [__v_57]; - record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_676] = [__v_57]; + record.function_queries[676].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -57050,18 +58418,19 @@ fn aiur_fn_670( }) } -const INPUT_SIZE_671: usize = 1; -const IN_671: usize = 1; -const OUT_671: usize = 1; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_677: usize = 1; +const IN_677: usize = 1; +const OUT_677: usize = 1; +fn aiur_fn_677( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], ExecError> { +) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(677); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -57072,15 +58441,15 @@ fn aiur_fn_671( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_671] = [__v_9]; - record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_677] = [__v_9]; + record.function_queries[677].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -57105,11 +58474,11 @@ fn aiur_fn_671( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[677].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i)?; } record.function_queries[677].output_at(__i).to_array::() }, _ => aiur_fn_677(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_671] = [__v_23]; - record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_677] = [__v_23]; + record.function_queries[677].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57119,20 +58488,21 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 3; -const IN_672: usize = 3; -const OUT_672: usize = 1; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_678: usize = 3; +const IN_678: usize = 3; +const OUT_678: usize = 1; +fn aiur_fn_678( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_678], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; + record.checkpoint(678); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[295].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i)?; } record.function_queries[295].output_at(__i).to_array::() }, _ => aiur_fn_295(__key, 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]; @@ -57141,7 +58511,7 @@ fn aiur_fn_672( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[295].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i)?; } record.function_queries[295].output_at(__i).to_array::() }, _ => aiur_fn_295(__key, 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]; @@ -57154,65 +58524,66 @@ fn aiur_fn_672( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_30: G = G::from_u64(1); let __v_31: G = G::from_u64(1); - let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } }; + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_2, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_23, __v_26, __v_29, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[73].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i)?; } record.function_queries[73].output_at(__i).to_array::() }, _ => aiur_fn_73(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_672] = [__v_34]; - record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_678] = [__v_34]; + record.function_queries[678].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_673: usize = 15; -const IN_673: usize = 15; -const OUT_673: usize = 1; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_679: usize = 15; +const IN_679: usize = 15; +const OUT_679: usize = 1; +fn aiur_fn_679( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], ExecError> { +) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(679); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; let __v_15: G = (__v_12 - __v_14); match __v_15.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_18]; - record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_679] = [__v_18]; + record.function_queries[679].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_10, __v_11, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[292].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i)?; } record.function_queries[292].output_at(__i).to_array::() }, _ => aiur_fn_292(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -57227,20 +58598,20 @@ fn aiur_fn_673( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[672].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[672].bump_multiplicity(__i); } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_11, __v_14, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[678].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i)?; } record.function_queries[678].output_at(__i).to_array::() }, _ => aiur_fn_678(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[685].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[685].bump_multiplicity(__i)?; } record.function_queries[685].output_at(__i).to_array::() }, _ => aiur_fn_685(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = (__v_14 + __v_34); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[679].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i)?; } record.function_queries[679].output_at(__i).to_array::() }, _ => aiur_fn_679(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_37]; - record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained); + let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_679] = [__v_37]; + record.function_queries[679].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57252,50 +58623,52 @@ fn aiur_fn_673( }) } -const INPUT_SIZE_674: usize = 5; -const IN_674: usize = 5; -const OUT_674: usize = 1; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_680: usize = 5; +const IN_680: usize = 5; +const OUT_680: usize = 1; +fn aiur_fn_680( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], ExecError> { +) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(680); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[681].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i)?; } record.function_queries[681].output_at(__i).to_array::() }, _ => aiur_fn_681(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_7]; - record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_680] = [__v_7]; + record.function_queries[680].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_675: usize = 8; -const IN_675: usize = 8; -const OUT_675: usize = 1; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_681: usize = 8; +const IN_681: usize = 8; +const OUT_681: usize = 1; +fn aiur_fn_681( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], ExecError> { +) -> Result<[G; OUT_681], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(681); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -57306,15 +58679,15 @@ fn aiur_fn_675( 1u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_675] = [__v_16]; - record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_681] = [__v_16]; + record.function_queries[681].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -57330,28 +58703,28 @@ fn aiur_fn_675( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[679].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i)?; } record.function_queries[679].output_at(__i).to_array::() }, _ => aiur_fn_679(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[681].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i)?; } record.function_queries[681].output_at(__i).to_array::() }, _ => aiur_fn_681(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_28, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_28, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_34]; - record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_681] = [__v_34]; + record.function_queries[681].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[681].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i)?; } record.function_queries[681].output_at(__i).to_array::() }, _ => aiur_fn_681(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_29]; - record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_681] = [__v_29]; + record.function_queries[681].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -57363,21 +58736,22 @@ fn aiur_fn_675( }) } -const INPUT_SIZE_676: usize = 5; -const IN_676: usize = 5; -const OUT_676: usize = 1; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_682: usize = 5; +const IN_682: usize = 5; +const OUT_682: usize = 1; +fn aiur_fn_682( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(682); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); @@ -57385,24 +58759,24 @@ fn aiur_fn_676( let __v_7: G = (__v_1 - __v_6); let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_10]; - record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_682] = [__v_10]; + record.function_queries[682].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_7, __v_2, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_676] = [__v_9]; - record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_682] = [__v_9]; + record.function_queries[682].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57411,9 +58785,9 @@ fn aiur_fn_676( let __v_9: G = (__v_1 - __v_8); let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); - let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_12]; - record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_682] = [__v_12]; + record.function_queries[682].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -57422,19 +58796,20 @@ fn aiur_fn_676( }) } -const INPUT_SIZE_677: usize = 2; -const IN_677: usize = 2; -const OUT_677: usize = 1; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_683: usize = 2; +const IN_683: usize = 2; +const OUT_683: usize = 1; +fn aiur_fn_683( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], ExecError> { +) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(683); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -57443,93 +58818,94 @@ fn aiur_fn_677( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[683].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[683].bump_multiplicity(__i)?; } record.function_queries[683].output_at(__i).to_array::() }, _ => aiur_fn_683(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_677] = [__v_8]; - record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_683] = [__v_8]; + record.function_queries[683].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_677] = [__v_1]; - record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_683] = [__v_1]; + record.function_queries[683].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_678: usize = 7; -const IN_678: usize = 7; -const OUT_678: usize = 1; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_684: usize = 7; +const IN_684: usize = 7; +const OUT_684: usize = 1; +fn aiur_fn_684( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], ExecError> { +) -> Result<[G; OUT_684], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(684); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_678] = [__v_0]; - record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_684] = [__v_0]; + record.function_queries[684].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[682].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i)?; } record.function_queries[682].output_at(__i).to_array::() }, _ => aiur_fn_682(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_9, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[684].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i)?; } record.function_queries[684].output_at(__i).to_array::() }, _ => aiur_fn_684(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_18]; - record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_684] = [__v_18]; + record.function_queries[684].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[682].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i)?; } record.function_queries[682].output_at(__i).to_array::() }, _ => aiur_fn_682(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_17, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[369].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i)?; } record.function_queries[369].output_at(__i).to_array::() }, _ => aiur_fn_369(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_1 - __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 + __v_24); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[684].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i)?; } record.function_queries[684].output_at(__i).to_array::() }, _ => aiur_fn_684(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_26]; - record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_684] = [__v_26]; + record.function_queries[684].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57543,65 +58919,66 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 13; -const IN_679: usize = 13; -const OUT_679: usize = 1; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_685: usize = 13; +const IN_685: usize = 13; +const OUT_685: usize = 1; +fn aiur_fn_685( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], ExecError> { +) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __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 __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } }; + record.checkpoint(685); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[338].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i)?; } record.function_queries[338].output_at(__i).to_array::() }, _ => aiur_fn_338(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = (__v_9 + __v_10); let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[684].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i)?; } record.function_queries[684].output_at(__i).to_array::() }, _ => aiur_fn_684(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_22: G = G::from_u64(1); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[696].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i)?; } record.function_queries[696].output_at(__i).to_array::() }, _ => aiur_fn_696(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_38, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_38, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[683].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[683].bump_multiplicity(__i); } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_39, __v_34, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[689].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i)?; } record.function_queries[689].output_at(__i).to_array::() }, _ => aiur_fn_689(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -57609,71 +58986,73 @@ fn aiur_fn_679( let __v_45: G = (__v_43 - __v_44); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_48, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_48, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[685].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[685].bump_multiplicity(__i); } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[691].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i)?; } record.function_queries[691].output_at(__i).to_array::() }, _ => aiur_fn_691(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_53, __v_33, __v_35, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[690].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i)?; } record.function_queries[690].output_at(__i).to_array::() }, _ => aiur_fn_690(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[688].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i)?; } record.function_queries[688].output_at(__i).to_array::() }, _ => aiur_fn_688(__key, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_58, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_58, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_61, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_61, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_679] = [__v_62]; - record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_685] = [__v_62]; + record.function_queries[685].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_680: usize = 1; -const IN_680: usize = 1; -const OUT_680: usize = 2; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_686: usize = 1; +const IN_686: usize = 1; +const OUT_686: usize = 2; +fn aiur_fn_686( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], ExecError> { +) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(686); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[687].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i)?; } record.function_queries[687].output_at(__i).to_array::() }, _ => aiur_fn_687(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[768].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i)?; } record.function_queries[768].output_at(__i).to_array::() }, _ => aiur_fn_768(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_680] = [__v_6, __v_5]; - record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_686] = [__v_6, __v_5]; + record.function_queries[686].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_681: usize = 2; -const IN_681: usize = 2; -const OUT_681: usize = 2; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_687: usize = 2; +const IN_687: usize = 2; +const OUT_687: usize = 2; +fn aiur_fn_687( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], ExecError> { +) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(687); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -57681,42 +59060,43 @@ fn aiur_fn_681( match __v_2.as_canonical_u64() { 5u64 => { let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[687].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i)?; } record.function_queries[687].output_at(__i).to_array::() }, _ => aiur_fn_687(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_681] = [__v_8, __v_9]; - record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_687] = [__v_8, __v_9]; + record.function_queries[687].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_681] = [__v_1, __v_0]; - record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_687] = [__v_1, __v_0]; + record.function_queries[687].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_682: usize = 8; -const IN_682: usize = 8; -const OUT_682: usize = 1; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_688: usize = 8; +const IN_688: usize = 8; +const OUT_688: usize = 1; +fn aiur_fn_688( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(688); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -57724,31 +59104,31 @@ fn aiur_fn_682( 1u64 => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_682] = [__v_13]; - record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_688] = [__v_13]; + record.function_queries[688].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_1, __v_7, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[762].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i)?; } record.function_queries[762].output_at(__i).to_array::() }, _ => aiur_fn_762(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[762].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i)?; } record.function_queries[762].output_at(__i).to_array::() }, _ => aiur_fn_762(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_5 + __v_7); let __v_16: G = (__v_6 + __v_15); - let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[772].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i)?; } record.function_queries[772].output_at(__i).to_array::() }, _ => aiur_fn_772(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_9); let __v_19: G = (__v_18 + __v_7); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_17, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[686].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i)?; } record.function_queries[686].output_at(__i).to_array::() }, _ => aiur_fn_686(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -57761,38 +59141,38 @@ fn aiur_fn_682( let __v_33: G = (__v_31 - __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_23, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_23, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_39, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_39, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_43, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_43, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_47, __v_24, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[655].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i)?; } record.function_queries[655].output_at(__i).to_array::() }, _ => aiur_fn_655(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); - let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_52, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_52, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[656].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i)?; } record.function_queries[656].output_at(__i).to_array::() }, _ => aiur_fn_656(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[688].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i)?; } record.function_queries[688].output_at(__i).to_array::() }, _ => aiur_fn_688(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_682] = [__v_58]; - record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained); + let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_688] = [__v_58]; + record.function_queries[688].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57802,20 +59182,21 @@ fn aiur_fn_682( }) } -const INPUT_SIZE_683: usize = 3; -const IN_683: usize = 3; -const OUT_683: usize = 1; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_689: usize = 3; +const IN_689: usize = 3; +const OUT_689: usize = 1; +fn aiur_fn_689( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], ExecError> { +) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(689); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -57823,20 +59204,20 @@ fn aiur_fn_683( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_683] = [__v_8]; - record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_689] = [__v_8]; + record.function_queries[689].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[683].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[683].bump_multiplicity(__i); } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[689].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i)?; } record.function_queries[689].output_at(__i).to_array::() }, _ => aiur_fn_689(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_683] = [__v_9]; - record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_689] = [__v_9]; + record.function_queries[689].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57846,25 +59227,26 @@ fn aiur_fn_683( }) } -const INPUT_SIZE_684: usize = 4; -const IN_684: usize = 4; -const OUT_684: usize = 1; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_690: usize = 4; +const IN_690: usize = 4; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], ExecError> { +) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(690); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_684] = [__v_0]; - record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_690] = [__v_0]; + record.function_queries[690].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -57873,120 +59255,123 @@ fn aiur_fn_684( let __v_7: G = (__v_2 - __v_6); let __v_8: G = (__v_7 - __v_3); let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_13, __v_1, __v_2, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[690].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i)?; } record.function_queries[690].output_at(__i).to_array::() }, _ => aiur_fn_690(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_684] = [__v_16]; - record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_690] = [__v_16]; + record.function_queries[690].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_685: usize = 6; -const IN_685: usize = 6; -const OUT_685: usize = 1; -fn aiur_fn_685( - inp: [G; IN_685], +const INPUT_SIZE_691: usize = 6; +const IN_691: usize = 6; +const OUT_691: usize = 1; +fn aiur_fn_691( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_685], ExecError> { +) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(691); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; match __v_4.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_2, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[663].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i)?; } record.function_queries[663].output_at(__i).to_array::() }, _ => aiur_fn_663(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_9]; - record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_691] = [__v_9]; + record.function_queries[691].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[653].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i)?; } record.function_queries[653].output_at(__i).to_array::() }, _ => aiur_fn_653(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_7]; - record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_691] = [__v_7]; + record.function_queries[691].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_686: usize = 3; -const IN_686: usize = 3; -const OUT_686: usize = 2; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_692: usize = 3; +const IN_692: usize = 3; +const OUT_692: usize = 2; +fn aiur_fn_692( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } }; + record.checkpoint(692); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[693].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i)?; } record.function_queries[693].output_at(__i).to_array::() }, _ => aiur_fn_693(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_686] = [__v_3, __v_4]; - record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_692] = [__v_3, __v_4]; + record.function_queries[692].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_687: usize = 3; -const IN_687: usize = 3; -const OUT_687: usize = 2; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_693: usize = 3; +const IN_693: usize = 3; +const OUT_693: usize = 2; +fn aiur_fn_693( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_693], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(693); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[423].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i)?; } record.function_queries[423].output_at(__i).to_array::() }, _ => aiur_fn_423(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_9, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[693].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i)?; } record.function_queries[693].output_at(__i).to_array::() }, _ => aiur_fn_693(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_687] = [__v_11, __v_12]; - record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_693] = [__v_11, __v_12]; + record.function_queries[693].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; @@ -57994,18 +59379,18 @@ fn aiur_fn_687( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[694].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i)?; } record.function_queries[694].output_at(__i).to_array::() }, _ => aiur_fn_694(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_687] = [__v_18, __v_19]; - record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_693] = [__v_18, __v_19]; + record.function_queries[693].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_687] = [__v_17, __v_18]; - record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_693] = [__v_17, __v_18]; + record.function_queries[693].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58014,22 +59399,23 @@ fn aiur_fn_687( }) } -const INPUT_SIZE_688: usize = 5; -const IN_688: usize = 5; -const OUT_688: usize = 2; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_694: usize = 5; +const IN_694: usize = 5; +const OUT_694: usize = 2; +fn aiur_fn_694( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_688], ExecError> { +) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(694); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -58040,12 +59426,12 @@ fn aiur_fn_688( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_688] = [__v_11, __v_12]; - record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_694] = [__v_11, __v_12]; + record.function_queries[694].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { @@ -58053,7 +59439,7 @@ fn aiur_fn_688( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_8, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[695].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i)?; } record.function_queries[695].output_at(__i).to_array::() }, _ => aiur_fn_695(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -58064,18 +59450,18 @@ fn aiur_fn_688( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_688] = [__v_14, __v_4]; - record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_694] = [__v_14, __v_4]; + record.function_queries[694].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[694].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i)?; } record.function_queries[694].output_at(__i).to_array::() }, _ => aiur_fn_694(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_688] = [__v_16, __v_17]; - record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_694] = [__v_16, __v_17]; + record.function_queries[694].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58087,60 +59473,61 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 3; -const IN_689: usize = 3; -const OUT_689: usize = 1; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_695: usize = 3; +const IN_695: usize = 3; +const OUT_695: usize = 1; +fn aiur_fn_695( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_695], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(695); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_689] = [__v_6]; - record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_695] = [__v_6]; + record.function_queries[695].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_689] = [__v_9]; - record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_695] = [__v_9]; + record.function_queries[695].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[637].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i)?; } record.function_queries[637].output_at(__i).to_array::() }, _ => aiur_fn_637(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[695].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i)?; } record.function_queries[695].output_at(__i).to_array::() }, _ => aiur_fn_695(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_689] = [__v_12]; - record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_695] = [__v_12]; + record.function_queries[695].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_689] = [__v_12]; - record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_695] = [__v_12]; + record.function_queries[695].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58157,24 +59544,25 @@ fn aiur_fn_689( }) } -const INPUT_SIZE_690: usize = 7; -const IN_690: usize = 7; -const OUT_690: usize = 4; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_696: usize = 7; +const IN_696: usize = 7; +const OUT_696: usize = 4; +fn aiur_fn_696( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], ExecError> { +) -> Result<[G; OUT_696], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(696); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -58182,72 +59570,73 @@ fn aiur_fn_690( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_8, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[692].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[692].bump_multiplicity(__i)?; } record.function_queries[692].output_at(__i).to_array::() }, _ => aiur_fn_692(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_8, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; match __v_12.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(0); - let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[696].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i)?; } record.function_queries[696].output_at(__i).to_array::() }, _ => aiur_fn_696(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __ret: [G; OUT_690] = [__v_22, __v_23, __v_24, __v_25]; - record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_696] = [__v_22, __v_23, __v_24, __v_25]; + record.function_queries[696].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[696].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i)?; } record.function_queries[696].output_at(__i).to_array::() }, _ => aiur_fn_696(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __ret: [G; OUT_690] = [__v_18, __v_19, __v_20, __v_21]; - record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_696] = [__v_18, __v_19, __v_20, __v_21]; + record.function_queries[696].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[768].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i)?; } record.function_queries[768].output_at(__i).to_array::() }, _ => aiur_fn_768(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[768].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i)?; } record.function_queries[768].output_at(__i).to_array::() }, _ => aiur_fn_768(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[768].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i)?; } record.function_queries[768].output_at(__i).to_array::() }, _ => aiur_fn_768(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_690] = [__v_11, __v_12, __v_13, __v_0]; - record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_696] = [__v_11, __v_12, __v_13, __v_0]; + record.function_queries[696].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_691: usize = 4; -const IN_691: usize = 4; -const OUT_691: usize = 1; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_697: usize = 4; +const IN_697: usize = 4; +const OUT_697: usize = 1; +fn aiur_fn_697( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], ExecError> { +) -> Result<[G; OUT_697], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(697); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -58258,15 +59647,15 @@ fn aiur_fn_691( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_691] = [__v_12]; - record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_697] = [__v_12]; + record.function_queries[697].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -58281,26 +59670,26 @@ fn aiur_fn_691( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[661].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i)?; } record.function_queries[661].output_at(__i).to_array::() }, _ => aiur_fn_661(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_23, __v_3, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[360].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i)?; } record.function_queries[360].output_at(__i).to_array::() }, _ => aiur_fn_360(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_3 + __v_27); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_9, __v_1, __v_2, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[697].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i)?; } record.function_queries[697].output_at(__i).to_array::() }, _ => aiur_fn_697(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_691] = [__v_30]; - record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained); + let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_697] = [__v_30]; + record.function_queries[697].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_9, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[697].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i)?; } record.function_queries[697].output_at(__i).to_array::() }, _ => aiur_fn_697(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_691] = [__v_23]; - record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_697] = [__v_23]; + record.function_queries[697].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58312,36 +59701,37 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 13; -const IN_692: usize = 13; -const OUT_692: usize = 0; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_698: usize = 13; +const IN_698: usize = 13; +const OUT_698: usize = 0; +fn aiur_fn_698( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_692], ExecError> { +) -> Result<[G; OUT_698], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(698); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[629].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i)?; } record.function_queries[629].output_at(__i).to_array::() }, _ => aiur_fn_629(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_15: G = __loaded[0]; let __v_16: G = __loaded[1]; let __v_17: G = __loaded[2]; @@ -58356,12 +59746,12 @@ fn aiur_fn_692( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[627].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i)?; } record.function_queries[627].output_at(__i).to_array::() }, _ => aiur_fn_627(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[627].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i)?; } record.function_queries[627].output_at(__i).to_array::() }, _ => aiur_fn_627(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 * __v_31); @@ -58371,11 +59761,11 @@ fn aiur_fn_692( let __v_36: G = (__v_34 + __v_35); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_36 + __v_37); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_7, __v_41, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[701].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i)?; } record.function_queries[701].output_at(__i).to_array::() }, _ => aiur_fn_701(__key, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -58388,15 +59778,15 @@ fn aiur_fn_692( return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[699].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i)?; } record.function_queries[699].output_at(__i).to_array::() }, _ => aiur_fn_699(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[625].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[625].bump_multiplicity(__i)?; } record.function_queries[625].output_at(__i).to_array::() }, _ => aiur_fn_625(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[617].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i)?; } record.function_queries[617].output_at(__i).to_array::() }, _ => aiur_fn_617(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[782].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i)?; } record.function_queries[782].output_at(__i).to_array::() }, _ => aiur_fn_782(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); @@ -58404,9 +59794,9 @@ fn aiur_fn_692( if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_692] = []; - record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[667].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[667].bump_multiplicity(__i)?; } record.function_queries[667].output_at(__i).to_array::() }, _ => aiur_fn_667(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_698] = []; + record.function_queries[698].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -58421,44 +59811,45 @@ fn aiur_fn_692( }) } -const INPUT_SIZE_693: usize = 6; -const IN_693: usize = 6; -const OUT_693: usize = 0; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_699: usize = 6; +const IN_699: usize = 6; +const OUT_699: usize = 0; +fn aiur_fn_699( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_693], ExecError> { +) -> Result<[G; OUT_699], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(699); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[592].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i)?; } record.function_queries[592].output_at(__i).to_array::() }, _ => aiur_fn_592(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } - let __ret: [G; OUT_693] = []; - record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_699] = []; + record.function_queries[699].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -58468,60 +59859,62 @@ fn aiur_fn_693( }) } -const INPUT_SIZE_694: usize = 2; -const IN_694: usize = 2; -const OUT_694: usize = 1; -fn aiur_fn_694( - inp: [G; IN_694], +const INPUT_SIZE_700: usize = 2; +const IN_700: usize = 2; +const OUT_700: usize = 1; +fn aiur_fn_700( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_694], ExecError> { +) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(700); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = (__v_0 - __v_1); match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_694] = [__v_5]; - record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_700] = [__v_5]; + record.function_queries[700].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_0, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[700].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i)?; } record.function_queries[700].output_at(__i).to_array::() }, _ => aiur_fn_700(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_694] = [__v_10]; - record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained); + let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_700] = [__v_10]; + record.function_queries[700].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_695: usize = 3; -const IN_695: usize = 3; -const OUT_695: usize = 0; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_701: usize = 3; +const IN_701: usize = 3; +const OUT_701: usize = 0; +fn aiur_fn_701( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_695], ExecError> { +) -> Result<[G; OUT_701], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(701); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -58529,18 +59922,18 @@ fn aiur_fn_695( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_695] = []; - record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_701] = []; + record.function_queries[701].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_695] = []; - record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_7, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[701].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i)?; } record.function_queries[701].output_at(__i).to_array::() }, _ => aiur_fn_701(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_701] = []; + record.function_queries[701].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58552,28 +59945,29 @@ fn aiur_fn_695( }) } -const INPUT_SIZE_696: usize = 4; -const IN_696: usize = 4; -const OUT_696: usize = 3; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_702: usize = 4; +const IN_702: usize = 4; +const OUT_702: usize = 3; +fn aiur_fn_702( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_696], ExecError> { +) -> Result<[G; OUT_702], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(702); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; - record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_702] = [__v_0, __v_2, __v_3]; + record.function_queries[702].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -58585,18 +59979,18 @@ fn aiur_fn_696( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_6, __v_9, __v_11, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[702].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i)?; } record.function_queries[702].output_at(__i).to_array::() }, _ => aiur_fn_702(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_696] = [__v_14, __v_15, __v_16]; - record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_702] = [__v_14, __v_15, __v_16]; + record.function_queries[702].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; - record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_702] = [__v_0, __v_2, __v_3]; + record.function_queries[702].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58605,81 +59999,82 @@ fn aiur_fn_696( }) } -const INPUT_SIZE_697: usize = 13; -const IN_697: usize = 13; -const OUT_697: usize = 0; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_703: usize = 13; +const IN_703: usize = 13; +const OUT_703: usize = 0; +fn aiur_fn_703( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_697], ExecError> { +) -> Result<[G; OUT_703], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i); } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } }; + record.checkpoint(703); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[581].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i)?; } record.function_queries[581].output_at(__i).to_array::() }, _ => aiur_fn_581(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_3, __v_15, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __v_2, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[505].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i)?; } record.function_queries[505].output_at(__i).to_array::() }, _ => aiur_fn_505(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_3, __v_15, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_19, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[326].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i)?; } record.function_queries[326].output_at(__i).to_array::() }, _ => aiur_fn_326(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -58687,74 +60082,74 @@ fn aiur_fn_697( } let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __v_2, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[505].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i)?; } record.function_queries[505].output_at(__i).to_array::() }, _ => aiur_fn_505(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_3, __v_15, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); - let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_3, __v_2, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[505].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i)?; } record.function_queries[505].output_at(__i).to_array::() }, _ => aiur_fn_505(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[585].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => aiur_fn_585(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_12, __v_3, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[591].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i)?; } record.function_queries[591].output_at(__i).to_array::() }, _ => aiur_fn_591(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[580].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i)?; } record.function_queries[580].output_at(__i).to_array::() }, _ => aiur_fn_580(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[615].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i)?; } record.function_queries[615].output_at(__i).to_array::() }, _ => aiur_fn_615(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[618].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i)?; } record.function_queries[618].output_at(__i).to_array::() }, _ => aiur_fn_618(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[291].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i)?; } record.function_queries[291].output_at(__i).to_array::() }, _ => aiur_fn_291(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -58769,15 +60164,15 @@ fn aiur_fn_697( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_22, __v_2, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[598].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i)?; } record.function_queries[598].output_at(__i).to_array::() }, _ => aiur_fn_598(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[596].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i)?; } record.function_queries[596].output_at(__i).to_array::() }, _ => aiur_fn_596(__key, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_22, __v_32, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[599].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i)?; } record.function_queries[599].output_at(__i).to_array::() }, _ => aiur_fn_599(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_6, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[602].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i)?; } record.function_queries[602].output_at(__i).to_array::() }, _ => aiur_fn_602(__key, record, io_buffer, __cu)? } }; if (__v_6 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } @@ -58785,15 +60180,15 @@ fn aiur_fn_697( 0u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => aiur_fn_608(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_2, __v_6, __v_3, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[614].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i)?; } record.function_queries[614].output_at(__i).to_array::() }, _ => aiur_fn_614(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -58805,17 +60200,17 @@ fn aiur_fn_697( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[586].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i)?; } record.function_queries[586].output_at(__i).to_array::() }, _ => aiur_fn_586(__key, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_2, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[504].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i)?; } record.function_queries[504].output_at(__i).to_array::() }, _ => aiur_fn_504(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_697] = []; - record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_13, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[583].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i)?; } record.function_queries[583].output_at(__i).to_array::() }, _ => aiur_fn_583(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[580].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i)?; } record.function_queries[580].output_at(__i).to_array::() }, _ => aiur_fn_580(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[698].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i)?; } record.function_queries[698].output_at(__i).to_array::() }, _ => aiur_fn_698(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -58825,20 +60220,21 @@ fn aiur_fn_697( }) } -const INPUT_SIZE_698: usize = 1; -const IN_698: usize = 1; -const OUT_698: usize = 0; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_704: usize = 1; +const IN_704: usize = 1; +const OUT_704: usize = 0; +fn aiur_fn_704( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_698], ExecError> { +) -> Result<[G; OUT_704], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + record.checkpoint(704); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -58851,25 +60247,26 @@ fn aiur_fn_698( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_698] = []; - record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[703].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i)?; } record.function_queries[703].output_at(__i).to_array::() }, _ => aiur_fn_703(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_704] = []; + record.function_queries[704].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_699: usize = 1; -const IN_699: usize = 1; -const OUT_699: usize = 1; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_705: usize = 1; +const IN_705: usize = 1; +const OUT_705: usize = 1; +fn aiur_fn_705( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], ExecError> { +) -> Result<[G; OUT_705], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + record.checkpoint(705); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58891,99 +60288,100 @@ fn aiur_fn_699( match __v_1.as_canonical_u64() { 2u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_24]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_705] = [__v_24]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[17].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i)?; } record.function_queries[17].output_at(__i).to_array::() }, _ => aiur_fn_17(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_22]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_705] = [__v_22]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_705] = [__v_21]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_705] = [__v_21]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_21]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_705] = [__v_21]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_19, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_699] = [__v_23]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_705] = [__v_23]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_699] = [__v_21]; - record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained); + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_705] = [__v_21]; + record.function_queries[705].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_700: usize = 1; -const IN_700: usize = 1; -const OUT_700: usize = 1; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_706: usize = 1; +const IN_706: usize = 1; +const OUT_706: usize = 1; +fn aiur_fn_706( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], ExecError> { +) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(706); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -58991,20 +60389,20 @@ fn aiur_fn_700( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_700] = [__v_6]; - record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_706] = [__v_6]; + record.function_queries[706].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[706].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i)?; } record.function_queries[706].output_at(__i).to_array::() }, _ => aiur_fn_706(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_700] = [__v_6]; - record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_706] = [__v_6]; + record.function_queries[706].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -59014,18 +60412,19 @@ fn aiur_fn_700( }) } -const INPUT_SIZE_701: usize = 1; -const IN_701: usize = 1; -const OUT_701: usize = 1; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_707: usize = 1; +const IN_707: usize = 1; +const OUT_707: usize = 1; +fn aiur_fn_707( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_701], ExecError> { +) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + record.checkpoint(707); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<11>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -59041,22 +60440,22 @@ fn aiur_fn_701( 1u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_701] = [__v_14]; - record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_707] = [__v_14]; + record.function_queries[707].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[707].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i)?; } record.function_queries[707].output_at(__i).to_array::() }, _ => aiur_fn_707(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_701] = [__v_14]; - record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_707] = [__v_14]; + record.function_queries[707].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59068,18 +60467,19 @@ fn aiur_fn_701( }) } -const INPUT_SIZE_702: usize = 1; -const IN_702: usize = 1; -const OUT_702: usize = 1; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_708: usize = 1; +const IN_708: usize = 1; +const OUT_708: usize = 1; +fn aiur_fn_708( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], ExecError> { +) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + record.checkpoint(708); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<36>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -59120,22 +60520,22 @@ fn aiur_fn_702( 1u64 => { let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_702] = [__v_39]; - record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_708] = [__v_39]; + record.function_queries[708].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[708].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i)?; } record.function_queries[708].output_at(__i).to_array::() }, _ => aiur_fn_708(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_702] = [__v_39]; - record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_708] = [__v_39]; + record.function_queries[708].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59147,18 +60547,19 @@ fn aiur_fn_702( }) } -const INPUT_SIZE_703: usize = 1; -const IN_703: usize = 1; -const OUT_703: usize = 1; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_709: usize = 1; +const IN_709: usize = 1; +const OUT_709: usize = 1; +fn aiur_fn_709( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], ExecError> { +) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(709); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -59210,9 +60611,9 @@ fn aiur_fn_703( 1u64 => { let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); - let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_703] = [__v_50]; - record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained); + let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_709] = [__v_50]; + record.function_queries[709].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -59220,18 +60621,18 @@ fn aiur_fn_703( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[709].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i)?; } record.function_queries[709].output_at(__i).to_array::() }, _ => aiur_fn_709(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_50, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_709] = [__v_52]; + record.function_queries[709].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59239,18 +60640,18 @@ fn aiur_fn_703( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[708].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i)?; } record.function_queries[708].output_at(__i).to_array::() }, _ => aiur_fn_708(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[709].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i)?; } record.function_queries[709].output_at(__i).to_array::() }, _ => aiur_fn_709(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_50, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_709] = [__v_52]; + record.function_queries[709].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59258,18 +60659,18 @@ fn aiur_fn_703( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[707].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i)?; } record.function_queries[707].output_at(__i).to_array::() }, _ => aiur_fn_707(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[709].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i)?; } record.function_queries[709].output_at(__i).to_array::() }, _ => aiur_fn_709(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_50, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_703] = [__v_52]; - record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_709] = [__v_52]; + record.function_queries[709].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59286,82 +60687,83 @@ fn aiur_fn_703( }) } -const INPUT_SIZE_704: usize = 48; -const IN_704: usize = 48; -const OUT_704: usize = 1; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_710: usize = 48; +const IN_710: usize = 48; +const OUT_710: usize = 1; +fn aiur_fn_710( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], ExecError> { +) -> Result<[G; OUT_710], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; + record.checkpoint(710); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[706].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i)?; } record.function_queries[706].output_at(__i).to_array::() }, _ => aiur_fn_706(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_52]; - record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_710] = [__v_52]; + record.function_queries[710].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59369,16 +60771,16 @@ fn aiur_fn_704( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[707].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i)?; } record.function_queries[707].output_at(__i).to_array::() }, _ => aiur_fn_707(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_52]; - record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_710] = [__v_52]; + record.function_queries[710].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59386,12 +60788,12 @@ fn aiur_fn_704( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_710] = [__v_50]; + record.function_queries[710].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59399,28 +60801,28 @@ fn aiur_fn_704( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[705].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i)?; } record.function_queries[705].output_at(__i).to_array::() }, _ => aiur_fn_705(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_710] = [__v_50]; + record.function_queries[710].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[709].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i)?; } record.function_queries[709].output_at(__i).to_array::() }, _ => aiur_fn_709(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_704] = [__v_50]; - record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_710] = [__v_50]; + record.function_queries[710].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __ret: [G; OUT_704] = [__v_48]; - record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_710] = [__v_48]; + record.function_queries[710].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59429,27 +60831,28 @@ fn aiur_fn_704( }) } -const INPUT_SIZE_705: usize = 2; -const IN_705: usize = 2; -const OUT_705: usize = 1; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_711: usize = 2; +const IN_711: usize = 2; +const OUT_711: usize = 1; +fn aiur_fn_711( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_705], ExecError> { +) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(711); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_705] = [__v_5]; - record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_711] = [__v_5]; + record.function_queries[711].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -59457,15 +60860,15 @@ fn aiur_fn_705( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_705] = [__v_6]; - record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_711] = [__v_6]; + record.function_queries[711].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[711].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i)?; } record.function_queries[711].output_at(__i).to_array::() }, _ => aiur_fn_711(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_705] = [__v_6]; - record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_711] = [__v_6]; + record.function_queries[711].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -59477,18 +60880,19 @@ fn aiur_fn_705( }) } -const INPUT_SIZE_706: usize = 1; -const IN_706: usize = 1; -const OUT_706: usize = 0; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_712: usize = 1; +const IN_712: usize = 1; +const OUT_712: usize = 0; +fn aiur_fn_712( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(712); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -59542,14 +60946,14 @@ fn aiur_fn_706( let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_2, __v_2, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[714].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i)?; } record.function_queries[714].output_at(__i).to_array::() }, _ => aiur_fn_714(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[712].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i)?; } record.function_queries[712].output_at(__i).to_array::() }, _ => aiur_fn_712(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59557,8 +60961,8 @@ fn aiur_fn_706( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[712].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i)?; } record.function_queries[712].output_at(__i).to_array::() }, _ => aiur_fn_712(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59566,8 +60970,8 @@ fn aiur_fn_706( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[712].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i)?; } record.function_queries[712].output_at(__i).to_array::() }, _ => aiur_fn_712(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -59575,59 +60979,60 @@ fn aiur_fn_706( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[712].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i)?; } record.function_queries[712].output_at(__i).to_array::() }, _ => aiur_fn_712(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[710].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i)?; } record.function_queries[710].output_at(__i).to_array::() }, _ => aiur_fn_710(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_706] = []; - record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_47, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[713].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i)?; } record.function_queries[713].output_at(__i).to_array::() }, _ => aiur_fn_713(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_712] = []; + record.function_queries[712].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_707: usize = 3; -const IN_707: usize = 3; -const OUT_707: usize = 0; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_713: usize = 3; +const IN_713: usize = 3; +const OUT_713: usize = 0; +fn aiur_fn_713( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], ExecError> { +) -> Result<[G; OUT_713], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(713); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_707] = []; - record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_713] = []; + record.function_queries[713].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[711].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i)?; } record.function_queries[711].output_at(__i).to_array::() }, _ => aiur_fn_711(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[712].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i)?; } record.function_queries[712].output_at(__i).to_array::() }, _ => aiur_fn_712(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -59637,9 +61042,9 @@ fn aiur_fn_707( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_707] = []; - record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_5, __v_1, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[713].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i)?; } record.function_queries[713].output_at(__i).to_array::() }, _ => aiur_fn_713(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_713] = []; + record.function_queries[713].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -59649,21 +61054,22 @@ fn aiur_fn_707( }) } -const INPUT_SIZE_708: usize = 4; -const IN_708: usize = 4; -const OUT_708: usize = 0; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_714: usize = 4; +const IN_714: usize = 4; +const OUT_714: usize = 0; +fn aiur_fn_714( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(714); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -59713,17 +61119,17 @@ fn aiur_fn_708( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_708] = []; - record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_714] = []; + record.function_queries[714].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[715].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i)?; } record.function_queries[715].output_at(__i).to_array::() }, _ => aiur_fn_715(__key, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_708] = []; - record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_1, __v_50, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[714].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i)?; } record.function_queries[714].output_at(__i).to_array::() }, _ => aiur_fn_714(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_714] = []; + record.function_queries[714].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -59733,69 +61139,70 @@ fn aiur_fn_708( }) } -const INPUT_SIZE_709: usize = 48; -const IN_709: usize = 48; -const OUT_709: usize = 0; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_715: usize = 48; +const IN_715: usize = 48; +const OUT_715: usize = 0; +fn aiur_fn_715( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], ExecError> { +) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } }; + record.checkpoint(715); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_0, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[296].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i)?; } record.function_queries[296].output_at(__i).to_array::() }, _ => aiur_fn_296(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[289].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i)?; } record.function_queries[289].output_at(__i).to_array::() }, _ => aiur_fn_289(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; + let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<12>() }; let __v_50: G = __loaded[0]; let __v_51: G = __loaded[1]; let __v_52: G = __loaded[2]; @@ -59808,98 +61215,101 @@ fn aiur_fn_709( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_709] = []; - record.function_queries[709].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[703].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i)?; } record.function_queries[703].output_at(__i).to_array::() }, _ => aiur_fn_703(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_715] = []; + record.function_queries[715].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_710: usize = 1; -const IN_710: usize = 1; -const OUT_710: usize = 1; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_716: usize = 1; +const IN_716: usize = 1; +const OUT_716: usize = 1; +fn aiur_fn_716( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(716); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_710] = [__v_8]; - record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_716] = [__v_8]; + record.function_queries[716].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_711: usize = 2; -const IN_711: usize = 2; -const OUT_711: usize = 1; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_717: usize = 2; +const IN_717: usize = 2; +const OUT_717: usize = 1; +fn aiur_fn_717( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(717); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_711] = [__v_10]; - record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_717] = [__v_10]; + record.function_queries[717].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_712: usize = 1; -const IN_712: usize = 1; -const OUT_712: usize = 3; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_718: usize = 1; +const IN_718: usize = 1; +const OUT_718: usize = 3; +fn aiur_fn_718( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(718); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[716].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i)?; } record.function_queries[716].output_at(__i).to_array::() }, _ => aiur_fn_716(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_712] = [__v_5, __v_10, __v_4]; - record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_718] = [__v_5, __v_10, __v_4]; + record.function_queries[718].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -59935,29 +61345,29 @@ fn aiur_fn_712( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_712] = [__v_35, __v_38, __v_2]; - record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_718] = [__v_35, __v_38, __v_2]; + record.function_queries[718].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[718].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i)?; } record.function_queries[718].output_at(__i).to_array::() }, _ => aiur_fn_718(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[718].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i)?; } record.function_queries[718].output_at(__i).to_array::() }, _ => aiur_fn_718(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i); } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[717].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i)?; } record.function_queries[717].output_at(__i).to_array::() }, _ => aiur_fn_717(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_712] = [__v_9, __v_10, __v_8]; - record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_718] = [__v_9, __v_10, __v_8]; + record.function_queries[718].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -59967,18 +61377,19 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 1; -const IN_713: usize = 1; -const OUT_713: usize = 1; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_719: usize = 1; +const IN_719: usize = 1; +const OUT_719: usize = 1; +fn aiur_fn_719( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(719); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -60016,9 +61427,9 @@ fn aiur_fn_713( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -60029,11 +61440,11 @@ fn aiur_fn_713( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[718].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i)?; } record.function_queries[718].output_at(__i).to_array::() }, _ => aiur_fn_718(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_51: G = __loaded[0]; let __v_52: G = __loaded[1]; let __v_53: G = __loaded[2]; @@ -60074,7 +61485,7 @@ fn aiur_fn_713( if (__v_39 != __v_84) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_84.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; @@ -60185,57 +61596,58 @@ fn aiur_fn_713( if (__v_82 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } - let __ret: [G; OUT_713] = [__v_49]; - record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_719] = [__v_49]; + record.function_queries[719].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_714: usize = 7; -const IN_714: usize = 7; -const OUT_714: usize = 6; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_720: usize = 7; +const IN_720: usize = 7; +const OUT_720: usize = 6; +fn aiur_fn_720( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(720); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_720] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[720].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[783].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i)?; } record.function_queries[783].output_at(__i).to_array::() }, _ => aiur_fn_783(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[720].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i)?; } record.function_queries[720].output_at(__i).to_array::() }, _ => aiur_fn_720(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; - let __ret: [G; OUT_714] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_720] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[720].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -60245,68 +61657,70 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 7; -const IN_715: usize = 7; -const OUT_715: usize = 1; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_721: usize = 7; +const IN_721: usize = 7; +const OUT_721: usize = 1; +fn aiur_fn_721( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], ExecError> { +) -> Result<[G; OUT_721], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(721); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[767].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i)?; } record.function_queries[767].output_at(__i).to_array::() }, _ => aiur_fn_767(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_715] = [__v_8]; - record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_721] = [__v_8]; + record.function_queries[721].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_716: usize = 14; -const IN_716: usize = 14; -const OUT_716: usize = 0; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_722: usize = 14; +const IN_722: usize = 14; +const OUT_722: usize = 0; +fn aiur_fn_722( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_722], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } }; + record.checkpoint(722); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[721].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i)?; } record.function_queries[721].output_at(__i).to_array::() }, _ => aiur_fn_721(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_716] = []; - record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_722] = []; + record.function_queries[722].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[721].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i)?; } record.function_queries[721].output_at(__i).to_array::() }, _ => aiur_fn_721(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -60319,7 +61733,7 @@ fn aiur_fn_716( }, } }; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -60373,14 +61787,14 @@ fn aiur_fn_716( let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0, __v_16, __v_16, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[714].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i)?; } record.function_queries[714].output_at(__i).to_array::() }, _ => aiur_fn_714(__key, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60388,8 +61802,8 @@ fn aiur_fn_716( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60397,8 +61811,8 @@ fn aiur_fn_716( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -60406,24 +61820,24 @@ fn aiur_fn_716( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[704].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i)?; } record.function_queries[704].output_at(__i).to_array::() }, _ => aiur_fn_704(__key, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[710].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i)?; } record.function_queries[710].output_at(__i).to_array::() }, _ => aiur_fn_710(__key, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_716] = []; - record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[723].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i)?; } record.function_queries[723].output_at(__i).to_array::() }, _ => aiur_fn_723(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_722] = []; + record.function_queries[722].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -60432,48 +61846,49 @@ fn aiur_fn_716( }) } -const INPUT_SIZE_717: usize = 16; -const IN_717: usize = 16; -const OUT_717: usize = 0; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_723: usize = 16; +const IN_723: usize = 16; +const OUT_723: usize = 0; +fn aiur_fn_723( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_723], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(723); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_717] = []; - record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_723] = []; + record.function_queries[723].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[711].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i)?; } record.function_queries[711].output_at(__i).to_array::() }, _ => aiur_fn_711(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -60483,9 +61898,9 @@ fn aiur_fn_717( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_717] = []; - record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[723].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i)?; } record.function_queries[723].output_at(__i).to_array::() }, _ => aiur_fn_723(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_723] = []; + record.function_queries[723].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -60495,45 +61910,46 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 13; -const IN_718: usize = 13; -const OUT_718: usize = 0; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_724: usize = 13; +const IN_724: usize = 13; +const OUT_724: usize = 0; +fn aiur_fn_724( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_718], ExecError> { +) -> Result<[G; OUT_724], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(724); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_718] = []; - record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_724] = []; + record.function_queries[724].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_718] = []; - record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[724].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i)?; } record.function_queries[724].output_at(__i).to_array::() }, _ => aiur_fn_724(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_724] = []; + record.function_queries[724].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -60543,30 +61959,31 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 3; -const IN_719: usize = 3; -const OUT_719: usize = 0; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_725: usize = 3; +const IN_725: usize = 3; +const OUT_725: usize = 0; +fn aiur_fn_725( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_719], ExecError> { +) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } }; + record.checkpoint(725); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[719].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i)?; } record.function_queries[719].output_at(__i).to_array::() }, _ => aiur_fn_719(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[719].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i)?; } record.function_queries[719].output_at(__i).to_array::() }, _ => aiur_fn_719(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -60578,7 +61995,7 @@ fn aiur_fn_719( let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[720].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i)?; } record.function_queries[720].output_at(__i).to_array::() }, _ => aiur_fn_720(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -60587,49 +62004,50 @@ fn aiur_fn_719( let __v_12: G = __r_arr[5]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[720].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i)?; } record.function_queries[720].output_at(__i).to_array::() }, _ => aiur_fn_720(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_719] = []; - record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[724].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i)?; } record.function_queries[724].output_at(__i).to_array::() }, _ => aiur_fn_724(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_725] = []; + record.function_queries[725].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_720: usize = 1; -const IN_720: usize = 1; -const OUT_720: usize = 3; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_726: usize = 1; +const IN_726: usize = 1; +const OUT_726: usize = 3; +fn aiur_fn_726( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], ExecError> { +) -> Result<[G; OUT_726], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(726); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, 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_720] = [__v_3, __v_4, __v_2]; - record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_726] = [__v_3, __v_4, __v_2]; + record.function_queries[726].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, 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_720] = [__v_5, __v_3, __v_4]; - record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_726] = [__v_5, __v_3, __v_4]; + record.function_queries[726].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -60639,28 +62057,29 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 2; -const IN_721: usize = 2; -const OUT_721: usize = 10; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 10; +fn aiur_fn_727( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], ExecError> { +) -> Result<[G; OUT_727], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(727); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_721] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_727] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[727].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -60671,124 +62090,127 @@ fn aiur_fn_721( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_721] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_727] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[727].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_722: usize = 2; -const IN_722: usize = 2; -const OUT_722: usize = 3; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_728: usize = 2; +const IN_728: usize = 2; +const OUT_728: usize = 3; +fn aiur_fn_728( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], ExecError> { +) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(728); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_722] = [__v_2, __v_3, __v_1]; - record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_728] = [__v_2, __v_3, __v_1]; + record.function_queries[728].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_722] = [__v_4, __v_2, __v_3]; - record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_728] = [__v_4, __v_2, __v_3]; + record.function_queries[728].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_723: usize = 2; -const IN_723: usize = 2; -const OUT_723: usize = 3; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_729: usize = 2; +const IN_729: usize = 2; +const OUT_729: usize = 3; +fn aiur_fn_729( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], ExecError> { +) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(729); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; - record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_729] = [__v_2, __v_3, __v_1]; + record.function_queries[729].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_723] = [__v_4, __v_2, __v_3]; - record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_729] = [__v_4, __v_2, __v_3]; + record.function_queries[729].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_724: usize = 2; -const IN_724: usize = 2; -const OUT_724: usize = 3; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_730: usize = 2; +const IN_730: usize = 2; +const OUT_730: usize = 3; +fn aiur_fn_730( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_730], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(730); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1]; - record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_730] = [__v_2, __v_3, __v_1]; + record.function_queries[730].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_730] = [__v_4, __v_5, __v_3]; + record.function_queries[730].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_730] = [__v_4, __v_5, __v_3]; + record.function_queries[730].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; - record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_730] = [__v_4, __v_5, __v_3]; + record.function_queries[730].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -60800,57 +62222,58 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 2; -const IN_725: usize = 2; -const OUT_725: usize = 3; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_731: usize = 2; +const IN_731: usize = 2; +const OUT_731: usize = 3; +fn aiur_fn_731( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_731], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(731); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_2, __v_3, __v_1]; - record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_731] = [__v_2, __v_3, __v_1]; + record.function_queries[731].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_731] = [__v_4, __v_5, __v_3]; + record.function_queries[731].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_731] = [__v_4, __v_5, __v_3]; + record.function_queries[731].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_731] = [__v_4, __v_5, __v_3]; + record.function_queries[731].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); - let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; - record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_731] = [__v_4, __v_5, __v_3]; + record.function_queries[731].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -60862,38 +62285,39 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 9; -const IN_726: usize = 9; -const OUT_726: usize = 2; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_732: usize = 9; +const IN_732: usize = 9; +const OUT_732: usize = 2; +fn aiur_fn_732( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], ExecError> { +) -> Result<[G; OUT_732], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(732); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_726] = [__v_12, __v_0]; - record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 19] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_732] = [__v_12, __v_0]; + record.function_queries[732].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[109].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i)?; } record.function_queries[109].output_at(__i).to_array::() }, _ => aiur_fn_109(__key, 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]; @@ -60912,7 +62336,7 @@ fn aiur_fn_726( let __v_25: G = __r_arr[15]; let __v_26: G = __r_arr[16]; let __v_27: G = __r_arr[17]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -60921,41 +62345,42 @@ fn aiur_fn_726( let __v_33: G = __r_arr[5]; let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i); } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[732].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i)?; } record.function_queries[732].output_at(__i).to_array::() }, _ => aiur_fn_732(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_726] = [__v_39, __v_37]; - record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained); + let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_732] = [__v_39, __v_37]; + record.function_queries[732].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_727: usize = 2; -const IN_727: usize = 2; -const OUT_727: usize = 3; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_733: usize = 2; +const IN_733: usize = 2; +const OUT_733: usize = 3; +fn aiur_fn_733( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], ExecError> { +) -> Result<[G; OUT_733], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(733); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; - record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_733] = [__v_2, __v_3, __v_1]; + record.function_queries[733].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -60965,30 +62390,31 @@ fn aiur_fn_727( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i); } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[732].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i)?; } record.function_queries[732].output_at(__i).to_array::() }, _ => aiur_fn_732(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; - record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_733] = [__v_13, __v_11, __v_12]; + record.function_queries[733].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_728: usize = 1; -const IN_728: usize = 1; -const OUT_728: usize = 41; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_734: usize = 1; +const IN_734: usize = 1; +const OUT_734: usize = 41; +fn aiur_fn_734( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], ExecError> { +) -> Result<[G; OUT_734], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(734); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -60998,7 +62424,7 @@ fn aiur_fn_728( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record)? }; let __v_10: G = __b1_out[0]; let __v_11: G = __b1_out[1]; let __v_12: G = __b1_out[2]; @@ -61007,11 +62433,11 @@ fn aiur_fn_728( let __v_15: G = __b1_out[5]; let __v_16: G = __b1_out[6]; let __v_17: G = __b1_out[7]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_10, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_11, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61022,7 +62448,7 @@ fn aiur_fn_728( 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_721] = { let __args: [G; IN_721] = [__v_12, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_12, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61033,7 +62459,7 @@ fn aiur_fn_728( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_13, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61044,7 +62470,7 @@ fn aiur_fn_728( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_14, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61055,28 +62481,29 @@ fn aiur_fn_728( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_15, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_728] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; - record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_734] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + record.function_queries[734].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_729: usize = 1; -const IN_729: usize = 1; -const OUT_729: usize = 49; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_735: usize = 1; +const IN_735: usize = 1; +const OUT_735: usize = 49; +fn aiur_fn_735( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], ExecError> { +) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(735); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -61086,7 +62513,7 @@ fn aiur_fn_729( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[734].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i)?; } record.function_queries[734].output_at(__i).to_array::() }, _ => aiur_fn_734(__key, 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]; @@ -61128,44 +62555,45 @@ fn aiur_fn_729( let __v_48: G = __r_arr[38]; let __v_49: G = __r_arr[39]; let __v_50: G = __r_arr[40]; - let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; - record.function_queries[729].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_735] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + record.function_queries[735].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_730: usize = 9; -const IN_730: usize = 9; -const OUT_730: usize = 2; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_736: usize = 9; +const IN_736: usize = 9; +const OUT_736: usize = 2; +fn aiur_fn_736( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], ExecError> { +) -> Result<[G; OUT_736], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(736); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_730] = [__v_12, __v_0]; - record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 50] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_736] = [__v_12, __v_0]; + record.function_queries[736].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[735].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i)?; } record.function_queries[735].output_at(__i).to_array::() }, _ => aiur_fn_735(__key, 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]; @@ -61215,7 +62643,7 @@ fn aiur_fn_730( let __v_56: G = __r_arr[46]; let __v_57: G = __r_arr[47]; let __v_58: G = __r_arr[48]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -61224,41 +62652,42 @@ fn aiur_fn_730( let __v_64: G = __r_arr[5]; let __v_65: G = __r_arr[6]; let __v_66: G = __r_arr[7]; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[736].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[736].bump_multiplicity(__i)?; } record.function_queries[736].output_at(__i).to_array::() }, _ => aiur_fn_736(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); - let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_730] = [__v_70, __v_68]; - record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained); + let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_736] = [__v_70, __v_68]; + record.function_queries[736].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_731: usize = 2; -const IN_731: usize = 2; -const OUT_731: usize = 3; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_737: usize = 2; +const IN_737: usize = 2; +const OUT_737: usize = 3; +fn aiur_fn_737( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], ExecError> { +) -> Result<[G; OUT_737], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(737); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_731] = [__v_2, __v_3, __v_1]; - record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_737] = [__v_2, __v_3, __v_1]; + record.function_queries[737].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -61268,33 +62697,34 @@ fn aiur_fn_731( 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_730] = { let __args: [G; IN_730] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[736].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[736].bump_multiplicity(__i)?; } record.function_queries[736].output_at(__i).to_array::() }, _ => aiur_fn_736(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_731] = [__v_13, __v_11, __v_12]; - record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_737] = [__v_13, __v_11, __v_12]; + record.function_queries[737].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_732: usize = 1; -const IN_732: usize = 1; -const OUT_732: usize = 55; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_738: usize = 1; +const IN_738: usize = 1; +const OUT_738: usize = 55; +fn aiur_fn_738( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(738); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -61304,7 +62734,7 @@ fn aiur_fn_732( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record)? }; let __v_12: G = __b1_out[0]; let __v_13: G = __b1_out[1]; let __v_14: G = __b1_out[2]; @@ -61313,7 +62743,7 @@ fn aiur_fn_732( let __v_17: G = __b1_out[5]; let __v_18: G = __b1_out[6]; let __v_19: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record)? }; let __v_20: G = __b1_out[0]; let __v_21: G = __b1_out[1]; let __v_22: G = __b1_out[2]; @@ -61324,15 +62754,15 @@ fn aiur_fn_732( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[730].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i)?; } record.function_queries[730].output_at(__i).to_array::() }, _ => aiur_fn_730(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[730].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i)?; } record.function_queries[730].output_at(__i).to_array::() }, _ => aiur_fn_730(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_14, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61343,26 +62773,26 @@ fn aiur_fn_732( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_15, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_16, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_738] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + record.function_queries[738].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61373,7 +62803,7 @@ fn aiur_fn_732( 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_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_14, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61384,7 +62814,7 @@ fn aiur_fn_732( 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_721] = { let __args: [G; IN_721] = [__v_15, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_15, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61395,30 +62825,30 @@ fn aiur_fn_732( 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_722] = { let __args: [G; IN_722] = [__v_16, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_16, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[731].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[731].bump_multiplicity(__i); } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[737].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i)?; } record.function_queries[737].output_at(__i).to_array::() }, _ => aiur_fn_737(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); - let __ret: [G; OUT_732] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; - record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_738] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; + record.function_queries[738].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_14, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61429,7 +62859,7 @@ fn aiur_fn_732( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_15, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61440,7 +62870,7 @@ fn aiur_fn_732( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_16, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61451,7 +62881,7 @@ fn aiur_fn_732( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61462,7 +62892,7 @@ fn aiur_fn_732( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_18, __v_73]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61473,17 +62903,17 @@ fn aiur_fn_732( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_19, __v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_20, __v_86]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[733].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i)?; } record.function_queries[733].output_at(__i).to_array::() }, _ => aiur_fn_733(__key, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(2); - let __ret: [G; OUT_732] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_738] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + record.function_queries[738].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -61493,18 +62923,19 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 1; -const IN_733: usize = 1; -const OUT_733: usize = 63; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_739: usize = 1; +const IN_739: usize = 1; +const OUT_739: usize = 63; +fn aiur_fn_739( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_739], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + record.checkpoint(739); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -61514,7 +62945,7 @@ fn aiur_fn_733( 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_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[738].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i)?; } record.function_queries[738].output_at(__i).to_array::() }, _ => aiur_fn_738(__key, 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]; @@ -61570,44 +63001,45 @@ fn aiur_fn_733( let __v_62: G = __r_arr[52]; let __v_63: G = __r_arr[53]; let __v_64: G = __r_arr[54]; - let __ret: [G; OUT_733] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; - record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_739] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + record.function_queries[739].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_734: usize = 9; -const IN_734: usize = 9; -const OUT_734: usize = 2; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_740: usize = 9; +const IN_740: usize = 9; +const OUT_740: usize = 2; +fn aiur_fn_740( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], ExecError> { +) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + record.checkpoint(740); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_734] = [__v_12, __v_0]; - record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained); + let __v_12: G = { let __values: [G; 64] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_740] = [__v_12, __v_0]; + record.function_queries[740].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[739].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i)?; } record.function_queries[739].output_at(__i).to_array::() }, _ => aiur_fn_739(__key, 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]; @@ -61671,7 +63103,7 @@ fn aiur_fn_734( let __v_70: G = __r_arr[60]; let __v_71: G = __r_arr[61]; let __v_72: G = __r_arr[62]; - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, 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]; @@ -61680,34 +63112,35 @@ fn aiur_fn_734( let __v_78: G = __r_arr[5]; let __v_79: G = __r_arr[6]; let __v_80: G = __r_arr[7]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[740].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i)?; } record.function_queries[740].output_at(__i).to_array::() }, _ => aiur_fn_740(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); - let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_734] = [__v_84, __v_82]; - record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained); + let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_740] = [__v_84, __v_82]; + record.function_queries[740].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_735: usize = 1; -const IN_735: usize = 1; -const OUT_735: usize = 55; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_741: usize = 1; +const IN_741: usize = 1; +const OUT_741: usize = 55; +fn aiur_fn_741( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_741], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } }; + record.checkpoint(741); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[74].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i)?; } record.function_queries[74].output_at(__i).to_array::() }, _ => aiur_fn_74(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -61717,7 +63150,7 @@ fn aiur_fn_735( let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record)? }; let __v_12: G = __b1_out[0]; let __v_13: G = __b1_out[1]; let __v_14: G = __b1_out[2]; @@ -61726,7 +63159,7 @@ fn aiur_fn_735( let __v_17: G = __b1_out[5]; let __v_18: G = __b1_out[6]; let __v_19: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record)? }; let __v_20: G = __b1_out[0]; let __v_21: G = __b1_out[1]; let __v_22: G = __b1_out[2]; @@ -61737,15 +63170,15 @@ fn aiur_fn_735( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[730].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i)?; } record.function_queries[730].output_at(__i).to_array::() }, _ => aiur_fn_730(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[730].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i)?; } record.function_queries[730].output_at(__i).to_array::() }, _ => aiur_fn_730(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_14, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61756,30 +63189,30 @@ fn aiur_fn_735( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_15, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_16, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_14, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61790,7 +63223,7 @@ fn aiur_fn_735( let __v_41: G = __r_arr[7]; let __v_42: G = __r_arr[8]; let __v_43: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_15, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61801,7 +63234,7 @@ fn aiur_fn_735( let __v_51: G = __r_arr[7]; let __v_52: G = __r_arr[8]; let __v_53: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_16, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61812,7 +63245,7 @@ fn aiur_fn_735( let __v_61: G = __r_arr[7]; let __v_62: G = __r_arr[8]; let __v_63: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_17, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61823,7 +63256,7 @@ fn aiur_fn_735( let __v_71: G = __r_arr[7]; let __v_72: G = __r_arr[8]; let __v_73: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_18, __v_73]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -61834,25 +63267,25 @@ fn aiur_fn_735( let __v_81: G = __r_arr[7]; let __v_82: G = __r_arr[8]; let __v_83: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_19, __v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_20, __v_86]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[733].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i)?; } record.function_queries[733].output_at(__i).to_array::() }, _ => aiur_fn_733(__key, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(1); - let __ret: [G; OUT_735] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[729].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i)?; } record.function_queries[729].output_at(__i).to_array::() }, _ => aiur_fn_729(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61863,22 +63296,22 @@ fn aiur_fn_735( 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_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_14, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[731].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[731].bump_multiplicity(__i)?; } record.function_queries[731].output_at(__i).to_array::() }, _ => aiur_fn_731(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_13, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61889,18 +63322,18 @@ fn aiur_fn_735( 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_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_14, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61911,7 +63344,7 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_13, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -61922,18 +63355,18 @@ fn aiur_fn_735( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_14, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61944,18 +63377,18 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_13, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61966,18 +63399,18 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_13, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[727].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i)?; } record.function_queries[727].output_at(__i).to_array::() }, _ => aiur_fn_727(__key, 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]; @@ -61988,14 +63421,14 @@ fn aiur_fn_735( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_13, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[728].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i)?; } record.function_queries[728].output_at(__i).to_array::() }, _ => aiur_fn_728(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { @@ -62003,11 +63436,11 @@ fn aiur_fn_735( 0u64 => { let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_30, __v_11]; }, 1u64 => { - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -62017,7 +63450,7 @@ fn aiur_fn_735( let __v_34: G = __r_arr[6]; let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[740].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i)?; } record.function_queries[740].output_at(__i).to_array::() }, _ => aiur_fn_740(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -62031,8 +63464,8 @@ fn aiur_fn_735( let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = G::from_u64(8); let __v_31: G = G::from_u64(0); - let __ret: [G; OUT_735] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; - record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_741] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + record.function_queries[741].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62042,18 +63475,19 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 1; -const IN_736: usize = 1; -const OUT_736: usize = 1; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_742: usize = 1; +const IN_742: usize = 1; +const OUT_742: usize = 1; +fn aiur_fn_742( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_742], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + record.checkpoint(742); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<18>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -62074,45 +63508,46 @@ fn aiur_fn_736( let __v_18: G = __loaded[17]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); - let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[22].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i)?; } record.function_queries[22].output_at(__i).to_array::() }, _ => aiur_fn_22(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_736] = [__v_23]; - record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_742] = [__v_23]; + record.function_queries[742].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_737: usize = 1; -const IN_737: usize = 1; -const OUT_737: usize = 1; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_743: usize = 1; +const IN_743: usize = 1; +const OUT_743: usize = 1; +fn aiur_fn_743( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], ExecError> { +) -> Result<[G; OUT_743], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(743); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_737] = [__v_1]; - record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_743] = [__v_1]; + record.function_queries[743].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_737] = [__v_1]; - record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_743] = [__v_1]; + record.function_queries[743].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_737] = [__v_1]; - record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_743] = [__v_1]; + record.function_queries[743].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62122,35 +63557,36 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 3; -const IN_738: usize = 3; -const OUT_738: usize = 0; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_744: usize = 3; +const IN_744: usize = 3; +const OUT_744: usize = 0; +fn aiur_fn_744( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], ExecError> { +) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(744); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_738] = []; - record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_744] = []; + record.function_queries[744].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[743].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i)?; } record.function_queries[743].output_at(__i).to_array::() }, _ => aiur_fn_743(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[743].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i)?; } record.function_queries[743].output_at(__i).to_array::() }, _ => aiur_fn_743(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } - let __ret: [G; OUT_738] = []; - record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_744] = []; + record.function_queries[744].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62160,35 +63596,36 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 3; -const IN_739: usize = 3; -const OUT_739: usize = 0; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_745: usize = 3; +const IN_745: usize = 3; +const OUT_745: usize = 0; +fn aiur_fn_745( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], ExecError> { +) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(745); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_739] = []; - record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_745] = []; + record.function_queries[745].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[743].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i)?; } record.function_queries[743].output_at(__i).to_array::() }, _ => aiur_fn_743(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[743].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i)?; } record.function_queries[743].output_at(__i).to_array::() }, _ => aiur_fn_743(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } - let __ret: [G; OUT_739] = []; - record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_745] = []; + record.function_queries[745].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62198,35 +63635,36 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 3; -const IN_740: usize = 3; -const OUT_740: usize = 0; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_746: usize = 3; +const IN_746: usize = 3; +const OUT_746: usize = 0; +fn aiur_fn_746( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(746); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_740] = []; - record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_746] = []; + record.function_queries[746].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } - let __ret: [G; OUT_740] = []; - record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_746] = []; + record.function_queries[746].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62236,31 +63674,32 @@ fn aiur_fn_740( }) } -const INPUT_SIZE_741: usize = 3; -const IN_741: usize = 3; -const OUT_741: usize = 0; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_747: usize = 3; +const IN_747: usize = 3; +const OUT_747: usize = 0; +fn aiur_fn_747( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], ExecError> { +) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(747); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_741] = []; - record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_747] = []; + record.function_queries[747].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } - let __ret: [G; OUT_741] = []; - record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_747] = []; + record.function_queries[747].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62270,37 +63709,38 @@ fn aiur_fn_741( }) } -const INPUT_SIZE_742: usize = 17; -const IN_742: usize = 17; -const OUT_742: usize = 0; -fn aiur_fn_742( - inp: [G; IN_742], +const INPUT_SIZE_748: usize = 17; +const IN_748: usize = 17; +const OUT_748: usize = 0; +fn aiur_fn_748( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_742], ExecError> { +) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(748); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_742] = []; - record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_748] = []; + record.function_queries[748].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -62328,8 +63768,8 @@ fn aiur_fn_742( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } - let __ret: [G; OUT_742] = []; - record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_748] = []; + record.function_queries[748].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62339,27 +63779,28 @@ fn aiur_fn_742( }) } -const INPUT_SIZE_743: usize = 3; -const IN_743: usize = 3; -const OUT_743: usize = 0; -fn aiur_fn_743( - inp: [G; IN_743], +const INPUT_SIZE_749: usize = 3; +const IN_749: usize = 3; +const OUT_749: usize = 0; +fn aiur_fn_749( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_743], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(749); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_743] = []; - record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_749] = []; + record.function_queries[749].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -62392,7 +63833,7 @@ fn aiur_fn_743( let __v_32: G = __loaded[29]; let __v_33: G = __loaded[30]; let __v_34: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -62521,8 +63962,8 @@ fn aiur_fn_743( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } - let __ret: [G; OUT_743] = []; - record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_749] = []; + record.function_queries[749].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62532,29 +63973,30 @@ fn aiur_fn_743( }) } -const INPUT_SIZE_744: usize = 3; -const IN_744: usize = 3; -const OUT_744: usize = 0; -fn aiur_fn_744( - inp: [G; IN_744], +const INPUT_SIZE_750: usize = 3; +const IN_750: usize = 3; +const OUT_750: usize = 0; +fn aiur_fn_750( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_744], ExecError> { +) -> Result<[G; OUT_750], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(750); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_744] = []; - record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_750] = []; + record.function_queries[750].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[736].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[736].bump_multiplicity(__i); } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[742].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i)?; } record.function_queries[742].output_at(__i).to_array::() }, _ => aiur_fn_742(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -62587,7 +64029,7 @@ fn aiur_fn_744( let __v_33: G = __loaded[29]; let __v_34: G = __loaded[30]; let __v_35: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_36: G = __loaded[0]; let __v_37: G = __loaded[1]; let __v_38: G = __loaded[2]; @@ -62716,8 +64158,8 @@ fn aiur_fn_744( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } - let __ret: [G; OUT_744] = []; - record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_750] = []; + record.function_queries[750].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62727,27 +64169,28 @@ fn aiur_fn_744( }) } -const INPUT_SIZE_745: usize = 10; -const IN_745: usize = 10; -const OUT_745: usize = 0; -fn aiur_fn_745( - inp: [G; IN_745], +const INPUT_SIZE_751: usize = 10; +const IN_751: usize = 10; +const OUT_751: usize = 0; +fn aiur_fn_751( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_745], ExecError> { +) -> Result<[G; OUT_751], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; + record.checkpoint(751); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<19>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -62769,7 +64212,7 @@ fn aiur_fn_745( let __v_28: G = __loaded[18]; match __v_10.as_canonical_u64() { 1u64 => { - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<11>() }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -62783,8 +64226,8 @@ fn aiur_fn_745( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_745] = []; - record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_751] = []; + record.function_queries[751].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62793,7 +64236,7 @@ fn aiur_fn_745( } }, 0u64 => { - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<11>() }; let __v_29: G = __loaded[0]; let __v_30: G = __loaded[1]; let __v_31: G = __loaded[2]; @@ -62812,7 +64255,7 @@ fn aiur_fn_745( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_38, __v_40, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } @@ -62861,7 +64304,7 @@ fn aiur_fn_745( if (__v_37 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) }); } - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -62870,9 +64313,9 @@ fn aiur_fn_745( let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[745].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i); } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_745] = []; - record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[751].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[751].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[751].bump_multiplicity(__i)?; } record.function_queries[751].output_at(__i).to_array::() }, _ => aiur_fn_751(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_751] = []; + record.function_queries[751].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -62891,23 +64334,24 @@ fn aiur_fn_745( }) } -const INPUT_SIZE_746: usize = 3; -const IN_746: usize = 3; -const OUT_746: usize = 0; -fn aiur_fn_746( - inp: [G; IN_746], +const INPUT_SIZE_752: usize = 3; +const IN_752: usize = 3; +const OUT_752: usize = 0; +fn aiur_fn_752( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_746], ExecError> { +) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(752); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_746] = []; - record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_752] = []; + record.function_queries[752].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -62919,9 +64363,9 @@ fn aiur_fn_746( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[745].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i); } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => aiur_fn_745(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_746] = []; - record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[751].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[751].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[751].bump_multiplicity(__i)?; } record.function_queries[751].output_at(__i).to_array::() }, _ => aiur_fn_751(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + record.function_queries[752].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -62931,66 +64375,67 @@ fn aiur_fn_746( }) } -const INPUT_SIZE_747: usize = 49; -const IN_747: usize = 49; -const OUT_747: usize = 0; -fn aiur_fn_747( - inp: [G; IN_747], +const INPUT_SIZE_753: usize = 49; +const IN_753: usize = 49; +const OUT_753: usize = 0; +fn aiur_fn_753( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_747], ExecError> { +) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; + record.checkpoint(753); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[777].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i)?; } record.function_queries[777].output_at(__i).to_array::() }, _ => aiur_fn_777(__key, 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]; @@ -63029,14 +64474,14 @@ fn aiur_fn_747( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_747] = []; - record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_49, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_82, __v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_753] = []; + record.function_queries[753].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63045,19 +64490,20 @@ fn aiur_fn_747( }) } -const INPUT_SIZE_748: usize = 2; -const IN_748: usize = 2; -const OUT_748: usize = 0; -fn aiur_fn_748( - inp: [G; IN_748], +const INPUT_SIZE_754: usize = 2; +const IN_754: usize = 2; +const OUT_754: usize = 0; +fn aiur_fn_754( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_748], ExecError> { +) -> Result<[G; OUT_754], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr }; + record.checkpoint(754); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<50>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -63110,15 +64556,15 @@ fn aiur_fn_748( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_748] = []; - record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_754] = []; + record.function_queries[754].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[747].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i); } let __ret: [G; OUT_747] = unsafe { *(record.function_queries[747].output_at(__i).as_ptr() as *const [G; OUT_747]) }; __ret }, _ => aiur_fn_747(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_748] = []; - record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[753].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i)?; } record.function_queries[753].output_at(__i).to_array::() }, _ => aiur_fn_753(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[754].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i)?; } record.function_queries[754].output_at(__i).to_array::() }, _ => aiur_fn_754(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + record.function_queries[754].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -63128,29 +64574,30 @@ fn aiur_fn_748( }) } -const INPUT_SIZE_749: usize = 3; -const IN_749: usize = 3; -const OUT_749: usize = 0; -fn aiur_fn_749( - inp: [G; IN_749], +const INPUT_SIZE_755: usize = 3; +const IN_755: usize = 3; +const OUT_755: usize = 0; +fn aiur_fn_755( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_749], ExecError> { +) -> Result<[G; OUT_755], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(755); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_749] = []; - record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_755] = []; + record.function_queries[755].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_749] = []; - record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[754].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i)?; } record.function_queries[754].output_at(__i).to_array::() }, _ => aiur_fn_754(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_755] = []; + record.function_queries[755].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -63160,128 +64607,129 @@ fn aiur_fn_749( }) } -const INPUT_SIZE_750: usize = 99; -const IN_750: usize = 99; -const OUT_750: usize = 0; -fn aiur_fn_750( - inp: [G; IN_750], +const INPUT_SIZE_756: usize = 99; +const IN_756: usize = 99; +const OUT_756: usize = 0; +fn aiur_fn_756( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_750], ExecError> { +) -> Result<[G; OUT_756], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; + record.checkpoint(756); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; match __v_0.as_canonical_u64() { 0u64 => { match __v_45.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_1, __v_46, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[744].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i)?; } record.function_queries[744].output_at(__i).to_array::() }, _ => aiur_fn_744(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_2, __v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[745].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i)?; } record.function_queries[745].output_at(__i).to_array::() }, _ => aiur_fn_745(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_11, __v_59, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_12, __v_61, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_756] = []; + record.function_queries[756].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63296,14 +64744,14 @@ fn aiur_fn_750( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[749].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i); } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => aiur_fn_749(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_1, __v_46, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_26, __v_75, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_27, __v_77, __v_78]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[755].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i)?; } record.function_queries[755].output_at(__i).to_array::() }, _ => aiur_fn_755(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_756] = []; + record.function_queries[756].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63318,17 +64766,17 @@ fn aiur_fn_750( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; let __hit = record.function_queries[746].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_750] = []; - record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_1, __v_46, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_2, __v_48, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_43, __v_95, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_44, __v_97, __v_98]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[752].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i)?; } record.function_queries[752].output_at(__i).to_array::() }, _ => aiur_fn_752(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_756] = []; + record.function_queries[756].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63345,19 +64793,20 @@ fn aiur_fn_750( }) } -const INPUT_SIZE_751: usize = 2; -const IN_751: usize = 2; -const OUT_751: usize = 0; -fn aiur_fn_751( - inp: [G; IN_751], +const INPUT_SIZE_757: usize = 2; +const IN_757: usize = 2; +const OUT_757: usize = 0; +fn aiur_fn_757( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_751], ExecError> { +) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr }; + record.checkpoint(757); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<64>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -63424,12 +64873,12 @@ fn aiur_fn_751( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_751] = []; - record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_757] = []; + record.function_queries[757].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[774].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i)?; } record.function_queries[774].output_at(__i).to_array::() }, _ => aiur_fn_774(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -63475,10 +64924,10 @@ fn aiur_fn_751( let __v_108: G = __r_arr[42]; let __v_109: G = __r_arr[43]; let __v_110: G = __r_arr[44]; - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[750].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i); } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => aiur_fn_750(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[751].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[751].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[751].bump_multiplicity(__i); } let __ret: [G; OUT_751] = unsafe { *(record.function_queries[751].output_at(__i).as_ptr() as *const [G; OUT_751]) }; __ret }, _ => aiur_fn_751(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_751] = []; - record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[756].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i)?; } record.function_queries[756].output_at(__i).to_array::() }, _ => aiur_fn_756(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_0, __v_65]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[757].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i)?; } record.function_queries[757].output_at(__i).to_array::() }, _ => aiur_fn_757(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_757] = []; + record.function_queries[757].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -63488,72 +64937,73 @@ fn aiur_fn_751( }) } -const INPUT_SIZE_752: usize = 55; -const IN_752: usize = 55; -const OUT_752: usize = 0; -fn aiur_fn_752( - inp: [G; IN_752], +const INPUT_SIZE_758: usize = 55; +const IN_758: usize = 55; +const OUT_758: usize = 0; +fn aiur_fn_758( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_752], ExecError> { +) -> Result<[G; OUT_758], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } }; + record.checkpoint(758); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[284].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i)?; } record.function_queries[284].output_at(__i).to_array::() }, _ => aiur_fn_284(__key, 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]; @@ -63610,13 +65060,13 @@ fn aiur_fn_752( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_56, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[744].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i)?; } record.function_queries[744].output_at(__i).to_array::() }, _ => aiur_fn_744(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_57, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[745].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i)?; } record.function_queries[745].output_at(__i).to_array::() }, _ => aiur_fn_745(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_66, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_67, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63631,17 +65081,17 @@ fn aiur_fn_752( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[746].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => aiur_fn_746(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_57, __v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_98, __v_51, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_99, __v_53, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[752].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i)?; } record.function_queries[752].output_at(__i).to_array::() }, _ => aiur_fn_752(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63656,11 +65106,11 @@ fn aiur_fn_752( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_56, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[747].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i)?; } record.function_queries[747].output_at(__i).to_array::() }, _ => aiur_fn_747(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_65, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63675,11 +65125,11 @@ fn aiur_fn_752( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_56, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[746].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[746].bump_multiplicity(__i)?; } record.function_queries[746].output_at(__i).to_array::() }, _ => aiur_fn_746(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_65, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[750].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i)?; } record.function_queries[750].output_at(__i).to_array::() }, _ => aiur_fn_750(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63694,11 +65144,11 @@ fn aiur_fn_752( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_72, __v_20, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[749].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i)?; } record.function_queries[749].output_at(__i).to_array::() }, _ => aiur_fn_749(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63713,10 +65163,10 @@ fn aiur_fn_752( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_64, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[749].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i)?; } record.function_queries[749].output_at(__i).to_array::() }, _ => aiur_fn_749(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63731,10 +65181,10 @@ fn aiur_fn_752( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_64, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[749].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i)?; } record.function_queries[749].output_at(__i).to_array::() }, _ => aiur_fn_749(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63749,10 +65199,10 @@ fn aiur_fn_752( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[748].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i)?; } record.function_queries[748].output_at(__i).to_array::() }, _ => aiur_fn_748(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_64, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[749].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i)?; } record.function_queries[749].output_at(__i).to_array::() }, _ => aiur_fn_749(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -63765,9 +65215,9 @@ fn aiur_fn_752( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[751].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[751].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[751].bump_multiplicity(__i); } let __ret: [G; OUT_751] = unsafe { *(record.function_queries[751].output_at(__i).as_ptr() as *const [G; OUT_751]) }; __ret }, _ => aiur_fn_751(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_752] = []; - record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_56, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[757].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i)?; } record.function_queries[757].output_at(__i).to_array::() }, _ => aiur_fn_757(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_758] = []; + record.function_queries[758].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -63784,56 +65234,58 @@ fn aiur_fn_752( }) } -const INPUT_SIZE_753: usize = 2; -const IN_753: usize = 2; -const OUT_753: usize = 0; -fn aiur_fn_753( - inp: [G; IN_753], +const INPUT_SIZE_759: usize = 2; +const IN_759: usize = 2; +const OUT_759: usize = 0; +fn aiur_fn_759( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_753], ExecError> { +) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } }; + record.checkpoint(759); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[719].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i)?; } record.function_queries[719].output_at(__i).to_array::() }, _ => aiur_fn_719(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[422].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i)?; } record.function_queries[422].output_at(__i).to_array::() }, _ => aiur_fn_422(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } - let __ret: [G; OUT_753] = []; - record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_759] = []; + record.function_queries[759].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_754: usize = 8; -const IN_754: usize = 8; -const OUT_754: usize = 0; -fn aiur_fn_754( - inp: [G; IN_754], +const INPUT_SIZE_760: usize = 8; +const IN_760: usize = 8; +const OUT_760: usize = 0; +fn aiur_fn_760( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_754], ExecError> { +) -> Result<[G; OUT_760], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - 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]; + record.checkpoint(760); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(0); 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(0); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -63869,7 +65321,7 @@ fn aiur_fn_754( let __v_44: G = G::from_u64(91); let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -63880,14 +65332,14 @@ fn aiur_fn_754( let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(0); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_59: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[24].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i); } let __ret: [G; OUT_24] = unsafe { *(record.function_queries[24].output_at(__i).as_ptr() as *const [G; OUT_24]) }; __ret }, _ => aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[24].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[24].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[24].bump_multiplicity(__i)?; } record.function_queries[24].output_at(__i).to_array::() }, _ => aiur_fn_24(__key, 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]; @@ -63920,7 +65372,7 @@ fn aiur_fn_754( let __v_93: G = __r_arr[29]; let __v_94: G = __r_arr[30]; let __v_95: G = __r_arr[31]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -64043,26 +65495,26 @@ fn aiur_fn_754( } match __v_97.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_187]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[726].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i)?; } record.function_queries[726].output_at(__i).to_array::() }, _ => aiur_fn_726(__key, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; match __v_188.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_186]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_186]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[712].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i)?; } record.function_queries[712].output_at(__i).to_array::() }, _ => aiur_fn_712(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_760] = []; + record.function_queries[760].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_189]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_189]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[719].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i)?; } record.function_queries[719].output_at(__i).to_array::() }, _ => aiur_fn_719(__key, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; let __v_192: G = G::from_u64(1); let __v_193: G = G::from_u64(1); - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[720].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i)?; } record.function_queries[720].output_at(__i).to_array::() }, _ => aiur_fn_720(__key, record, io_buffer, __cu)? } }; let __v_194: G = __r_arr[0]; let __v_195: G = __r_arr[1]; let __v_196: G = __r_arr[2]; @@ -64072,9 +65524,9 @@ fn aiur_fn_754( let __v_200: G = G::from_u64(1); let __v_201: G = G::from_u64(1); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[722].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i)?; } record.function_queries[722].output_at(__i).to_array::() }, _ => aiur_fn_722(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_760] = []; + record.function_queries[760].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64083,23 +65535,23 @@ fn aiur_fn_754( } }, 5u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_187]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[726].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i)?; } record.function_queries[726].output_at(__i).to_array::() }, _ => aiur_fn_726(__key, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_186, __v_188, __v_189]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[725].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i)?; } record.function_queries[725].output_at(__i).to_array::() }, _ => aiur_fn_725(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_760] = []; + record.function_queries[760].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_187]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[741].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i)?; } record.function_queries[741].output_at(__i).to_array::() }, _ => aiur_fn_741(__key, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -64155,21 +65607,21 @@ fn aiur_fn_754( let __v_240: G = __r_arr[52]; let __v_241: G = __r_arr[53]; let __v_242: G = __r_arr[54]; - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[758].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i)?; } record.function_queries[758].output_at(__i).to_array::() }, _ => aiur_fn_758(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_760] = []; + record.function_queries[760].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_187]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_186, __v_188]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_754] = []; - record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained); + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_186, __v_188]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[759].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i)?; } record.function_queries[759].output_at(__i).to_array::() }, _ => aiur_fn_759(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_760] = []; + record.function_queries[760].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64179,59 +65631,61 @@ fn aiur_fn_754( }) } -const INPUT_SIZE_755: usize = 8; -const IN_755: usize = 8; -const OUT_755: usize = 0; -fn aiur_fn_755( - inp: [G; IN_755], +const INPUT_SIZE_761: usize = 8; +const IN_761: usize = 8; +const OUT_761: usize = 0; +fn aiur_fn_761( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_755], ExecError> { +) -> Result<[G; OUT_761], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_755] = []; - record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained); + record.checkpoint(761); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[760].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i)?; } record.function_queries[760].output_at(__i).to_array::() }, _ => aiur_fn_760(__key, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_761] = []; + record.function_queries[761].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_756: usize = 3; -const IN_756: usize = 3; -const OUT_756: usize = 1; -fn aiur_fn_756( - inp: [G; IN_756], +const INPUT_SIZE_762: usize = 3; +const IN_762: usize = 3; +const OUT_762: usize = 1; +fn aiur_fn_762( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_756], ExecError> { +) -> Result<[G; OUT_762], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + record.checkpoint(762); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_756] = [__v_2]; - record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_762] = [__v_2]; + record.function_queries[762].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_756] = [__v_5]; - record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_762] = [__v_5]; + record.function_queries[762].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64241,19 +65695,20 @@ fn aiur_fn_756( }) } -const INPUT_SIZE_757: usize = 2; -const IN_757: usize = 2; -const OUT_757: usize = 1; -fn aiur_fn_757( - inp: [G; IN_757], +const INPUT_SIZE_763: usize = 2; +const IN_763: usize = 2; +const OUT_763: usize = 1; +fn aiur_fn_763( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_757], ExecError> { +) -> Result<[G; OUT_763], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(763); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -64262,19 +65717,19 @@ fn aiur_fn_757( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_757] = [__v_9]; - record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_763] = [__v_9]; + record.function_queries[763].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[763].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i)?; } record.function_queries[763].output_at(__i).to_array::() }, _ => aiur_fn_763(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_757] = [__v_7]; - record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_763] = [__v_7]; + record.function_queries[763].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64284,18 +65739,19 @@ fn aiur_fn_757( }) } -const INPUT_SIZE_758: usize = 1; -const IN_758: usize = 1; -const OUT_758: usize = 8; -fn aiur_fn_758( - inp: [G; IN_758], +const INPUT_SIZE_764: usize = 1; +const IN_764: usize = 1; +const OUT_764: usize = 8; +fn aiur_fn_764( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_758], ExecError> { +) -> Result<[G; OUT_764], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(764); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64316,12 +65772,12 @@ fn aiur_fn_758( let __v_16: G = G::from_u64(0); let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_758] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_764] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[764].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[764].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i)?; } record.function_queries[764].output_at(__i).to_array::() }, _ => aiur_fn_764(__key, 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]; @@ -64330,7 +65786,7 @@ fn aiur_fn_758( let __v_16: G = __r_arr[5]; let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -64339,8 +65795,8 @@ fn aiur_fn_758( let __v_24: G = __r_arr[5]; let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; - let __ret: [G; OUT_758] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_764] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[764].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64350,36 +65806,37 @@ fn aiur_fn_758( }) } -const INPUT_SIZE_759: usize = 2; -const IN_759: usize = 2; -const OUT_759: usize = 1; -fn aiur_fn_759( - inp: [G; IN_759], +const INPUT_SIZE_765: usize = 2; +const IN_765: usize = 2; +const OUT_765: usize = 1; +fn aiur_fn_765( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_759], ExecError> { +) -> Result<[G; OUT_765], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(765); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_759] = [__v_1]; - record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_765] = [__v_1]; + record.function_queries[765].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[765].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i)?; } record.function_queries[765].output_at(__i).to_array::() }, _ => aiur_fn_765(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_759] = [__v_8]; - record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained); + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_765] = [__v_8]; + record.function_queries[765].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64389,18 +65846,19 @@ fn aiur_fn_759( }) } -const INPUT_SIZE_760: usize = 1; -const IN_760: usize = 1; -const OUT_760: usize = 8; -fn aiur_fn_760( - inp: [G; IN_760], +const INPUT_SIZE_766: usize = 1; +const IN_766: usize = 1; +const OUT_766: usize = 8; +fn aiur_fn_766( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_760], ExecError> { +) -> Result<[G; OUT_766], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(766); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64414,12 +65872,12 @@ fn aiur_fn_760( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_760] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_766] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[766].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[766].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i)?; } record.function_queries[766].output_at(__i).to_array::() }, _ => aiur_fn_766(__key, 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]; @@ -64428,7 +65886,7 @@ fn aiur_fn_760( let __v_9: G = __r_arr[5]; let __v_10: G = __r_arr[6]; let __v_11: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -64437,8 +65895,8 @@ fn aiur_fn_760( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __ret: [G; OUT_760] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_766] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[766].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64448,67 +65906,68 @@ fn aiur_fn_760( }) } -const INPUT_SIZE_761: usize = 8; -const IN_761: usize = 8; -const OUT_761: usize = 1; -fn aiur_fn_761( - inp: [G; IN_761], +const INPUT_SIZE_767: usize = 8; +const IN_767: usize = 8; +const OUT_767: usize = 1; +fn aiur_fn_767( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_761], ExecError> { +) -> Result<[G; OUT_767], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(767); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_761] = [__v_7]; - record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_767] = [__v_7]; + record.function_queries[767].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; - let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[767].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i)?; } record.function_queries[767].output_at(__i).to_array::() }, _ => aiur_fn_767(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_761] = [__v_21]; - record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_767] = [__v_21]; + record.function_queries[767].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_761] = [__v_4]; - record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_767] = [__v_4]; + record.function_queries[767].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[767].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i)?; } record.function_queries[767].output_at(__i).to_array::() }, _ => aiur_fn_767(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_761] = [__v_22]; - record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_767] = [__v_22]; + record.function_queries[767].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -64522,57 +65981,59 @@ fn aiur_fn_761( }) } -const INPUT_SIZE_762: usize = 1; -const IN_762: usize = 1; -const OUT_762: usize = 1; -fn aiur_fn_762( - inp: [G; IN_762], +const INPUT_SIZE_768: usize = 1; +const IN_768: usize = 1; +const OUT_768: usize = 1; +fn aiur_fn_768( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_762], ExecError> { +) -> Result<[G; OUT_768], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(768); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[785].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i)?; } record.function_queries[785].output_at(__i).to_array::() }, _ => aiur_fn_785(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_762] = [__v_4]; - record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_768] = [__v_4]; + record.function_queries[768].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } -const INPUT_SIZE_763: usize = 2; -const IN_763: usize = 2; -const OUT_763: usize = 1; -fn aiur_fn_763( - inp: [G; IN_763], +const INPUT_SIZE_769: usize = 2; +const IN_769: usize = 2; +const OUT_769: usize = 1; +fn aiur_fn_769( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_763], ExecError> { +) -> Result<[G; OUT_769], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(769); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_763] = [__v_1]; - record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_769] = [__v_1]; + record.function_queries[769].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[769].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i)?; } record.function_queries[769].output_at(__i).to_array::() }, _ => aiur_fn_769(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_763] = [__v_7]; - record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_769] = [__v_7]; + record.function_queries[769].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64582,35 +66043,36 @@ fn aiur_fn_763( }) } -const INPUT_SIZE_764: usize = 1; -const IN_764: usize = 1; -const OUT_764: usize = 1; -fn aiur_fn_764( - inp: [G; IN_764], +const INPUT_SIZE_770: usize = 1; +const IN_770: usize = 1; +const OUT_770: usize = 1; +fn aiur_fn_770( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_764], ExecError> { +) -> Result<[G; OUT_770], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(770); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_764] = [__v_4]; - record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_770] = [__v_4]; + record.function_queries[770].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[770].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i)?; } record.function_queries[770].output_at(__i).to_array::() }, _ => aiur_fn_770(__key, 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_764] = [__v_6]; - record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_770] = [__v_6]; + record.function_queries[770].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64620,18 +66082,19 @@ fn aiur_fn_764( }) } -const INPUT_SIZE_765: usize = 1; -const IN_765: usize = 1; -const OUT_765: usize = 8; -fn aiur_fn_765( - inp: [G; IN_765], +const INPUT_SIZE_771: usize = 1; +const IN_771: usize = 1; +const OUT_771: usize = 8; +fn aiur_fn_771( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_765], ExecError> { +) -> Result<[G; OUT_771], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + record.checkpoint(771); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<36>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64678,12 +66141,12 @@ fn aiur_fn_765( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __ret: [G; OUT_765] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_771] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[771].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[765].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => aiur_fn_765(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[771].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i)?; } record.function_queries[771].output_at(__i).to_array::() }, _ => aiur_fn_771(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -64692,7 +66155,7 @@ fn aiur_fn_765( let __v_42: G = __r_arr[5]; let __v_43: G = __r_arr[6]; let __v_44: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -64701,8 +66164,8 @@ fn aiur_fn_765( let __v_50: G = __r_arr[5]; let __v_51: G = __r_arr[6]; let __v_52: G = __r_arr[7]; - let __ret: [G; OUT_765] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_771] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[771].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64712,28 +66175,29 @@ fn aiur_fn_765( }) } -const INPUT_SIZE_766: usize = 2; -const IN_766: usize = 2; -const OUT_766: usize = 1; -fn aiur_fn_766( - inp: [G; IN_766], +const INPUT_SIZE_772: usize = 2; +const IN_772: usize = 2; +const OUT_772: usize = 1; +fn aiur_fn_772( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_766], ExecError> { +) -> Result<[G; OUT_772], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + record.checkpoint(772); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_766] = [__v_4]; - record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_772] = [__v_4]; + record.function_queries[772].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64743,18 +66207,19 @@ fn aiur_fn_766( }) } -const INPUT_SIZE_767: usize = 1; -const IN_767: usize = 1; -const OUT_767: usize = 1; -fn aiur_fn_767( - inp: [G; IN_767], +const INPUT_SIZE_773: usize = 1; +const IN_773: usize = 1; +const OUT_773: usize = 1; +fn aiur_fn_773( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_767], ExecError> { +) -> Result<[G; OUT_773], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(773); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -64768,17 +66233,17 @@ fn aiur_fn_767( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_767] = [__v_11]; - record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_773] = [__v_11]; + record.function_queries[773].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[773].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i)?; } record.function_queries[773].output_at(__i).to_array::() }, _ => aiur_fn_773(__key, 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_767] = [__v_13]; - record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_773] = [__v_13]; + record.function_queries[773].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64788,26 +66253,27 @@ fn aiur_fn_767( }) } -const INPUT_SIZE_768: usize = 9; -const IN_768: usize = 9; -const OUT_768: usize = 45; -fn aiur_fn_768( - inp: [G; IN_768], +const INPUT_SIZE_774: usize = 9; +const IN_774: usize = 9; +const OUT_774: usize = 45; +fn aiur_fn_774( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_768], ExecError> { +) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(774); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -64857,16 +66323,16 @@ fn aiur_fn_768( let __v_55: G = __loaded[46]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_768] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; - record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_774] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + record.function_queries[774].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; let __v_59: G = __r_arr[2]; @@ -64875,7 +66341,7 @@ fn aiur_fn_768( let __v_62: G = __r_arr[5]; let __v_63: G = __r_arr[6]; let __v_64: G = __r_arr[7]; - let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[774].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i)?; } record.function_queries[774].output_at(__i).to_array::() }, _ => aiur_fn_774(__key, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -64921,8 +66387,8 @@ fn aiur_fn_768( let __v_107: G = __r_arr[42]; let __v_108: G = __r_arr[43]; let __v_109: G = __r_arr[44]; - let __ret: [G; OUT_768] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; - record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_774] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + record.function_queries[774].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -64937,18 +66403,19 @@ fn aiur_fn_768( }) } -const INPUT_SIZE_769: usize = 1; -const IN_769: usize = 1; -const OUT_769: usize = 8; -fn aiur_fn_769( - inp: [G; IN_769], +const INPUT_SIZE_775: usize = 1; +const IN_775: usize = 1; +const OUT_775: usize = 8; +fn aiur_fn_775( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_769], ExecError> { +) -> Result<[G; OUT_775], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; + record.checkpoint(775); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<47>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -65006,12 +66473,12 @@ fn aiur_fn_769( let __v_53: G = G::from_u64(0); let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(0); - let __ret: [G; OUT_769] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_775] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[775].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[775].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i)?; } record.function_queries[775].output_at(__i).to_array::() }, _ => aiur_fn_775(__key, 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]; @@ -65020,7 +66487,7 @@ fn aiur_fn_769( let __v_53: G = __r_arr[5]; let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -65029,8 +66496,8 @@ fn aiur_fn_769( let __v_61: G = __r_arr[5]; let __v_62: G = __r_arr[6]; let __v_63: G = __r_arr[7]; - let __ret: [G; OUT_769] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_775] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[775].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65040,18 +66507,19 @@ fn aiur_fn_769( }) } -const INPUT_SIZE_770: usize = 1; -const IN_770: usize = 1; -const OUT_770: usize = 8; -fn aiur_fn_770( - inp: [G; IN_770], +const INPUT_SIZE_776: usize = 1; +const IN_776: usize = 1; +const OUT_776: usize = 8; +fn aiur_fn_776( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_770], ExecError> { +) -> Result<[G; OUT_776], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + record.checkpoint(776); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<11>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -65073,12 +66541,12 @@ fn aiur_fn_770( let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_770] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_776] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[776].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[776].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i)?; } record.function_queries[776].output_at(__i).to_array::() }, _ => aiur_fn_776(__key, 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]; @@ -65087,7 +66555,7 @@ fn aiur_fn_770( let __v_17: G = __r_arr[5]; let __v_18: G = __r_arr[6]; let __v_19: G = __r_arr[7]; - let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[15].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i)?; } record.function_queries[15].output_at(__i).to_array::() }, _ => aiur_fn_15(__key, 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]; @@ -65096,8 +66564,8 @@ fn aiur_fn_770( let __v_25: G = __r_arr[5]; let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; - let __ret: [G; OUT_770] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_776] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[776].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65107,26 +66575,27 @@ fn aiur_fn_770( }) } -const INPUT_SIZE_771: usize = 9; -const IN_771: usize = 9; -const OUT_771: usize = 34; -fn aiur_fn_771( - inp: [G; IN_771], +const INPUT_SIZE_777: usize = 9; +const IN_777: usize = 9; +const OUT_777: usize = 34; +fn aiur_fn_777( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_771], ExecError> { +) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; + record.checkpoint(777); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<36>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -65165,16 +66634,16 @@ fn aiur_fn_771( let __v_44: G = __loaded[35]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[5].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i)?; } record.function_queries[5].output_at(__i).to_array::() }, _ => aiur_fn_5(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_771] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_777] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + record.function_queries[777].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[16].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i)?; } record.function_queries[16].output_at(__i).to_array::() }, _ => aiur_fn_16(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -65183,7 +66652,7 @@ fn aiur_fn_771( let __v_51: G = __r_arr[5]; let __v_52: G = __r_arr[6]; let __v_53: G = __r_arr[7]; - let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[777].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i)?; } record.function_queries[777].output_at(__i).to_array::() }, _ => aiur_fn_777(__key, 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]; @@ -65218,8 +66687,8 @@ fn aiur_fn_771( let __v_85: G = __r_arr[31]; let __v_86: G = __r_arr[32]; let __v_87: G = __r_arr[33]; - let __ret: [G; OUT_771] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; - record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_777] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + record.function_queries[777].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65234,32 +66703,33 @@ fn aiur_fn_771( }) } -const INPUT_SIZE_772: usize = 1; -const IN_772: usize = 1; -const OUT_772: usize = 1; -fn aiur_fn_772( - inp: [G; IN_772], +const INPUT_SIZE_778: usize = 1; +const IN_778: usize = 1; +const OUT_778: usize = 1; +fn aiur_fn_778( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_772], ExecError> { +) -> Result<[G; OUT_778], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(778); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_772] = [__v_4]; - record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_778] = [__v_4]; + record.function_queries[778].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_772] = [__v_4]; - record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_778] = [__v_4]; + record.function_queries[778].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65269,22 +66739,23 @@ fn aiur_fn_772( }) } -const INPUT_SIZE_773: usize = 5; -const IN_773: usize = 5; -const OUT_773: usize = 1; -fn aiur_fn_773( - inp: [G; IN_773], +const INPUT_SIZE_779: usize = 5; +const IN_779: usize = 5; +const OUT_779: usize = 1; +fn aiur_fn_779( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_773], ExecError> { +) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(779); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -65296,19 +66767,19 @@ fn aiur_fn_773( let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_773] = [__v_15]; - record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained); + let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_779] = [__v_15]; + record.function_queries[779].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[779].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i)?; } record.function_queries[779].output_at(__i).to_array::() }, _ => aiur_fn_779(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_773] = [__v_13]; - record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained); + let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_779] = [__v_13]; + record.function_queries[779].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65318,29 +66789,30 @@ fn aiur_fn_773( }) } -const INPUT_SIZE_774: usize = 2; -const IN_774: usize = 2; -const OUT_774: usize = 1; -fn aiur_fn_774( - inp: [G; IN_774], +const INPUT_SIZE_780: usize = 2; +const IN_780: usize = 2; +const OUT_780: usize = 1; +fn aiur_fn_780( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_774], ExecError> { +) -> Result<[G; OUT_780], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(780); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_774] = [__v_4]; - record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_780] = [__v_4]; + record.function_queries[780].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -65349,11 +66821,11 @@ fn aiur_fn_774( 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_774] = { let __args: [G; IN_774] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[780].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i)?; } record.function_queries[780].output_at(__i).to_array::() }, _ => aiur_fn_780(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_774] = [__v_9]; - record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained); + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_780] = [__v_9]; + record.function_queries[780].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65365,37 +66837,38 @@ fn aiur_fn_774( }) } -const INPUT_SIZE_775: usize = 2; -const IN_775: usize = 2; -const OUT_775: usize = 1; -fn aiur_fn_775( - inp: [G; IN_775], +const INPUT_SIZE_781: usize = 2; +const IN_781: usize = 2; +const OUT_781: usize = 1; +fn aiur_fn_781( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_775], ExecError> { +) -> Result<[G; OUT_781], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(781); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_775] = [__v_0]; - record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_781] = [__v_0]; + record.function_queries[781].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[781].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i)?; } record.function_queries[781].output_at(__i).to_array::() }, _ => aiur_fn_781(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_775] = [__v_7]; - record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_781] = [__v_7]; + record.function_queries[781].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65407,18 +66880,19 @@ fn aiur_fn_775( }) } -const INPUT_SIZE_776: usize = 1; -const IN_776: usize = 1; -const OUT_776: usize = 1; -fn aiur_fn_776( - inp: [G; IN_776], +const INPUT_SIZE_782: usize = 1; +const IN_782: usize = 1; +const OUT_782: usize = 1; +fn aiur_fn_782( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_776], ExecError> { +) -> Result<[G; OUT_782], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(782); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -65427,17 +66901,17 @@ fn aiur_fn_776( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_776] = [__v_6]; - record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_782] = [__v_6]; + record.function_queries[782].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[782].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i)?; } record.function_queries[782].output_at(__i).to_array::() }, _ => aiur_fn_782(__key, 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_776] = [__v_8]; - record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_782] = [__v_8]; + record.function_queries[782].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65447,25 +66921,26 @@ fn aiur_fn_776( }) } -const INPUT_SIZE_777: usize = 8; -const IN_777: usize = 8; -const OUT_777: usize = 6; -fn aiur_fn_777( - inp: [G; IN_777], +const INPUT_SIZE_783: usize = 8; +const IN_783: usize = 8; +const OUT_783: usize = 6; +fn aiur_fn_783( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_777], ExecError> { +) -> Result<[G; OUT_783], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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 __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__args, record, io_buffer, __cu)? } }; + record.checkpoint(783); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[786].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i)?; } record.function_queries[786].output_at(__i).to_array::() }, _ => aiur_fn_786(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -65476,8 +66951,8 @@ fn aiur_fn_777( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_777] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[783].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65487,75 +66962,19 @@ fn aiur_fn_777( }) } -const INPUT_SIZE_778: usize = 9; -const IN_778: usize = 9; -const OUT_778: usize = 1; -fn aiur_fn_778( - inp: [G; IN_778], +const INPUT_SIZE_784: usize = 1; +const IN_784: usize = 1; +const OUT_784: usize = 1; +fn aiur_fn_784( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_778], ExecError> { +) -> Result<[G; OUT_784], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; - let __v_9: G = __loaded[0]; - let __v_10: G = __loaded[1]; - let __v_11: G = __loaded[2]; - let __v_12: G = __loaded[3]; - let __v_13: G = __loaded[4]; - let __v_14: G = __loaded[5]; - let __v_15: G = __loaded[6]; - let __v_16: G = __loaded[7]; - let __v_17: G = __loaded[8]; - let __v_18: G = __loaded[9]; - match __v_9.as_canonical_u64() { - 1u64 => { - let __v_19: G = G::from_u64(0); - let __v_20: G = G::from_u64(1); - let __v_21: G = G::from_u64(1); - let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 10] = [__v_19, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_778] = [__v_23]; - record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }, - 0u64 => { - let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } }; - let __v_20: G = __r_arr[0]; - let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_778] = [__v_21]; - record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained); - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); - }, - } - }) -} - -const INPUT_SIZE_779: usize = 1; -const IN_779: usize = 1; -const OUT_779: usize = 1; -fn aiur_fn_779( - inp: [G; IN_779], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_779], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(784); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -65565,17 +66984,17 @@ fn aiur_fn_779( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_779] = [__v_7]; - record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_784] = [__v_7]; + record.function_queries[784].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[784].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i)?; } record.function_queries[784].output_at(__i).to_array::() }, _ => aiur_fn_784(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); - let __ret: [G; OUT_779] = [__v_9]; - record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_784] = [__v_9]; + record.function_queries[784].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65585,35 +67004,36 @@ fn aiur_fn_779( }) } -const INPUT_SIZE_780: usize = 2; -const IN_780: usize = 2; -const OUT_780: usize = 1; -fn aiur_fn_780( - inp: [G; IN_780], +const INPUT_SIZE_785: usize = 2; +const IN_785: usize = 2; +const OUT_785: usize = 1; +fn aiur_fn_785( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_780], ExecError> { +) -> Result<[G; OUT_785], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(785); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_780] = [__v_1]; - record.function_queries[780].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_785] = [__v_1]; + record.function_queries[785].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[785].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i)?; } record.function_queries[785].output_at(__i).to_array::() }, _ => aiur_fn_785(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_780] = [__v_7]; - record.function_queries[780].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_785] = [__v_7]; + record.function_queries[785].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65623,72 +67043,73 @@ fn aiur_fn_780( }) } -const INPUT_SIZE_781: usize = 8; -const IN_781: usize = 8; -const OUT_781: usize = 6; -fn aiur_fn_781( - inp: [G; IN_781], +const INPUT_SIZE_786: usize = 8; +const IN_786: usize = 8; +const OUT_786: usize = 6; +fn aiur_fn_786( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_781], ExecError> { +) -> Result<[G; OUT_786], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(786); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_2.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_781] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained); + let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_786] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[786].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; let __v_12: G = __loaded[4]; let __v_13: G = __loaded[5]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; let __v_17: G = __loaded[3]; let __v_18: G = __loaded[4]; let __v_19: G = __loaded[5]; - let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[786].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i)?; } record.function_queries[786].output_at(__i).to_array::() }, _ => aiur_fn_786(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[787].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[787].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[787].bump_multiplicity(__i)?; } record.function_queries[787].output_at(__i).to_array::() }, _ => aiur_fn_787(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; - let __ret: [G; OUT_781] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_786] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[786].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65696,29 +67117,29 @@ fn aiur_fn_781( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_781] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained); + let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_786] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[786].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[786].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i)?; } record.function_queries[786].output_at(__i).to_array::() }, _ => aiur_fn_786(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[787].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[787].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[787].bump_multiplicity(__i)?; } record.function_queries[787].output_at(__i).to_array::() }, _ => aiur_fn_787(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; - let __ret: [G; OUT_781] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_786] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[786].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -65732,85 +67153,87 @@ fn aiur_fn_781( }) } -const INPUT_SIZE_782: usize = 15; -const IN_782: usize = 15; -const OUT_782: usize = 6; -fn aiur_fn_782( - inp: [G; IN_782], +const INPUT_SIZE_787: usize = 15; +const IN_787: usize = 15; +const OUT_787: usize = 6; +fn aiur_fn_787( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_782], ExecError> { +) -> Result<[G; OUT_787], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(787); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_1, __v_2, __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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[788].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[788].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[788].bump_multiplicity(__i)?; } record.function_queries[788].output_at(__i).to_array::() }, _ => aiur_fn_788(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __ret: [G; OUT_782] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - record.function_queries[782].finish(&inp[..], &__ret[..], !unconstrained); + let __ret: [G; OUT_787] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[787].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_782] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - record.function_queries[782].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_787] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[787].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }) } -const INPUT_SIZE_783: usize = 14; -const IN_783: usize = 14; -const OUT_783: usize = 6; -fn aiur_fn_783( - inp: [G; IN_783], +const INPUT_SIZE_788: usize = 14; +const IN_788: usize = 14; +const OUT_788: usize = 6; +fn aiur_fn_788( + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_783], ExecError> { +) -> Result<[G; OUT_788], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(788); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; match __v_2.as_canonical_u64() { 0u64 => { match __v_3.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -65825,17 +67248,17 @@ fn aiur_fn_783( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); - let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -65850,13 +67273,13 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -65864,7 +67287,7 @@ fn aiur_fn_783( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -65879,17 +67302,17 @@ fn aiur_fn_783( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65904,22 +67327,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -65927,10 +67350,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -65938,7 +67361,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -65953,22 +67376,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -65976,10 +67399,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -65989,10 +67412,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66000,10 +67423,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66015,7 +67438,7 @@ fn aiur_fn_783( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -66030,17 +67453,17 @@ fn aiur_fn_783( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66055,22 +67478,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66078,10 +67501,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66089,7 +67512,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66104,22 +67527,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66127,10 +67550,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66140,10 +67563,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66151,10 +67574,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66164,7 +67587,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66179,13 +67602,13 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); - let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -66193,7 +67616,7 @@ fn aiur_fn_783( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -66208,17 +67631,17 @@ fn aiur_fn_783( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66233,22 +67656,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66256,10 +67679,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66267,7 +67690,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66282,22 +67705,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66305,10 +67728,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66318,10 +67741,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66329,10 +67752,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66344,7 +67767,7 @@ fn aiur_fn_783( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -66359,17 +67782,17 @@ fn aiur_fn_783( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = G::from_u64(1); - let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_38, __v_39, __v_10, __v_11, __v_31, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66384,22 +67807,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66407,10 +67830,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66418,7 +67841,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_32: G = __loaded[0]; let __v_33: G = __loaded[1]; let __v_34: G = __loaded[2]; @@ -66433,22 +67856,22 @@ fn aiur_fn_783( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_46: G = { let __values: [G; 6] = [__v_44, __v_45, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66456,10 +67879,10 @@ fn aiur_fn_783( _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(1); - let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_40: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66469,10 +67892,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66480,10 +67903,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66497,7 +67920,7 @@ fn aiur_fn_783( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -66512,17 +67935,17 @@ fn aiur_fn_783( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66537,22 +67960,22 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66560,10 +67983,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66571,7 +67994,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66586,22 +68009,22 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66609,10 +68032,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66622,10 +68045,10 @@ fn aiur_fn_783( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66633,10 +68056,10 @@ fn aiur_fn_783( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66648,7 +68071,7 @@ fn aiur_fn_783( 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -66663,17 +68086,17 @@ fn aiur_fn_783( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); - let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_10, __v_11, __v_19, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66688,22 +68111,22 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66711,10 +68134,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66722,7 +68145,7 @@ fn aiur_fn_783( } }, _ => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -66737,22 +68160,22 @@ fn aiur_fn_783( let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(1); - let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(1); - let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_34: G = { let __values: [G; 6] = [__v_32, __v_33, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66760,10 +68183,10 @@ fn aiur_fn_783( _ => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66773,10 +68196,10 @@ fn aiur_fn_783( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66784,10 +68207,10 @@ fn aiur_fn_783( _ => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __ret: [G; OUT_788] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[788].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -66805,3922 +68228,3947 @@ pub(crate) fn execute_generated( match fun_idx as u64 { 0u64 => { let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_0(__inp, record, io_buffer, false)?; + let __out = aiur_fn_0(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 1u64 => { let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_1(__inp, record, io_buffer, false)?; + let __out = aiur_fn_1(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 2u64 => { let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_2(__inp, record, io_buffer, false)?; + let __out = aiur_fn_2(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 3u64 => { let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_3(__inp, record, io_buffer, false)?; + let __out = aiur_fn_3(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 4u64 => { let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_4(__inp, record, io_buffer, false)?; + let __out = aiur_fn_4(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 5u64 => { let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_5(__inp, record, io_buffer, false)?; + let __out = aiur_fn_5(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 6u64 => { let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_6(__inp, record, io_buffer, false)?; + let __out = aiur_fn_6(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 7u64 => { let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_7(__inp, record, io_buffer, false)?; + let __out = aiur_fn_7(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 8u64 => { let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_8(__inp, record, io_buffer, false)?; + let __out = aiur_fn_8(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 9u64 => { let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_9(__inp, record, io_buffer, false)?; + let __out = aiur_fn_9(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 10u64 => { let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_10(__inp, record, io_buffer, false)?; + let __out = aiur_fn_10(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 11u64 => { let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_11(__inp, record, io_buffer, false)?; + let __out = aiur_fn_11(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 12u64 => { let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_12(__inp, record, io_buffer, false)?; + let __out = aiur_fn_12(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 13u64 => { let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_13(__inp, record, io_buffer, false)?; + let __out = aiur_fn_13(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 14u64 => { let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_14(__inp, record, io_buffer, false)?; + let __out = aiur_fn_14(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 15u64 => { let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_15(__inp, record, io_buffer, false)?; + let __out = aiur_fn_15(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 16u64 => { let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_16(__inp, record, io_buffer, false)?; + let __out = aiur_fn_16(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 17u64 => { let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_17(__inp, record, io_buffer, false)?; + let __out = aiur_fn_17(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 18u64 => { let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_18(__inp, record, io_buffer, false)?; + let __out = aiur_fn_18(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 19u64 => { let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_19(__inp, record, io_buffer, false)?; + let __out = aiur_fn_19(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 20u64 => { let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_20(__inp, record, io_buffer, false)?; + let __out = aiur_fn_20(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 21u64 => { let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_21(__inp, record, io_buffer, false)?; + let __out = aiur_fn_21(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 22u64 => { let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_22(__inp, record, io_buffer, false)?; + let __out = aiur_fn_22(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 23u64 => { let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_23(__inp, record, io_buffer, false)?; + let __out = aiur_fn_23(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 24u64 => { let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_24(__inp, record, io_buffer, false)?; + let __out = aiur_fn_24(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 25u64 => { let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_25(__inp, record, io_buffer, false)?; + let __out = aiur_fn_25(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 26u64 => { let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_26(__inp, record, io_buffer, false)?; + let __out = aiur_fn_26(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 27u64 => { let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_27(__inp, record, io_buffer, false)?; + let __out = aiur_fn_27(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 28u64 => { let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_28(__inp, record, io_buffer, false)?; + let __out = aiur_fn_28(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 29u64 => { let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_29(__inp, record, io_buffer, false)?; + let __out = aiur_fn_29(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 30u64 => { let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_30(__inp, record, io_buffer, false)?; + let __out = aiur_fn_30(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 31u64 => { let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_31(__inp, record, io_buffer, false)?; + let __out = aiur_fn_31(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 32u64 => { let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_32(__inp, record, io_buffer, false)?; + let __out = aiur_fn_32(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 33u64 => { let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_33(__inp, record, io_buffer, false)?; + let __out = aiur_fn_33(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 34u64 => { let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_34(__inp, record, io_buffer, false)?; + let __out = aiur_fn_34(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 35u64 => { let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_35(__inp, record, io_buffer, false)?; + let __out = aiur_fn_35(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 36u64 => { let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_36(__inp, record, io_buffer, false)?; + let __out = aiur_fn_36(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 37u64 => { let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_37(__inp, record, io_buffer, false)?; + let __out = aiur_fn_37(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 38u64 => { let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_38(__inp, record, io_buffer, false)?; + let __out = aiur_fn_38(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 39u64 => { let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_39(__inp, record, io_buffer, false)?; + let __out = aiur_fn_39(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 40u64 => { let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_40(__inp, record, io_buffer, false)?; + let __out = aiur_fn_40(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 41u64 => { let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_41(__inp, record, io_buffer, false)?; + let __out = aiur_fn_41(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 42u64 => { let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_42(__inp, record, io_buffer, false)?; + let __out = aiur_fn_42(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 43u64 => { let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_43(__inp, record, io_buffer, false)?; + let __out = aiur_fn_43(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 44u64 => { let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_44(__inp, record, io_buffer, false)?; + let __out = aiur_fn_44(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 45u64 => { let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_45(__inp, record, io_buffer, false)?; + let __out = aiur_fn_45(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 46u64 => { let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_46(__inp, record, io_buffer, false)?; + let __out = aiur_fn_46(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 47u64 => { let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_47(__inp, record, io_buffer, false)?; + let __out = aiur_fn_47(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 48u64 => { let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_48(__inp, record, io_buffer, false)?; + let __out = aiur_fn_48(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 49u64 => { let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_49(__inp, record, io_buffer, false)?; + let __out = aiur_fn_49(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 50u64 => { let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_50(__inp, record, io_buffer, false)?; + let __out = aiur_fn_50(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 51u64 => { let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_51(__inp, record, io_buffer, false)?; + let __out = aiur_fn_51(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 52u64 => { let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_52(__inp, record, io_buffer, false)?; + let __out = aiur_fn_52(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 53u64 => { let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_53(__inp, record, io_buffer, false)?; + let __out = aiur_fn_53(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 54u64 => { let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_54(__inp, record, io_buffer, false)?; + let __out = aiur_fn_54(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 55u64 => { let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_55(__inp, record, io_buffer, false)?; + let __out = aiur_fn_55(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 56u64 => { let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_56(__inp, record, io_buffer, false)?; + let __out = aiur_fn_56(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 57u64 => { let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_57(__inp, record, io_buffer, false)?; + let __out = aiur_fn_57(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 58u64 => { let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_58(__inp, record, io_buffer, false)?; + let __out = aiur_fn_58(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 59u64 => { let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_59(__inp, record, io_buffer, false)?; + let __out = aiur_fn_59(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 60u64 => { let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_60(__inp, record, io_buffer, false)?; + let __out = aiur_fn_60(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 61u64 => { let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_61(__inp, record, io_buffer, false)?; + let __out = aiur_fn_61(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 62u64 => { let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_62(__inp, record, io_buffer, false)?; + let __out = aiur_fn_62(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 63u64 => { let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_63(__inp, record, io_buffer, false)?; + let __out = aiur_fn_63(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 64u64 => { let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_64(__inp, record, io_buffer, false)?; + let __out = aiur_fn_64(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 65u64 => { let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_65(__inp, record, io_buffer, false)?; + let __out = aiur_fn_65(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 66u64 => { let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_66(__inp, record, io_buffer, false)?; + let __out = aiur_fn_66(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 67u64 => { let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_67(__inp, record, io_buffer, false)?; + let __out = aiur_fn_67(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 68u64 => { let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_68(__inp, record, io_buffer, false)?; + let __out = aiur_fn_68(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 69u64 => { let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_69(__inp, record, io_buffer, false)?; + let __out = aiur_fn_69(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 70u64 => { let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_70(__inp, record, io_buffer, false)?; + let __out = aiur_fn_70(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 71u64 => { let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_71(__inp, record, io_buffer, false)?; + let __out = aiur_fn_71(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 72u64 => { let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_72(__inp, record, io_buffer, false)?; + let __out = aiur_fn_72(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 73u64 => { let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_73(__inp, record, io_buffer, false)?; + let __out = aiur_fn_73(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 74u64 => { let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_74(__inp, record, io_buffer, false)?; + let __out = aiur_fn_74(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 75u64 => { let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_75(__inp, record, io_buffer, false)?; + let __out = aiur_fn_75(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 76u64 => { let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_76(__inp, record, io_buffer, false)?; + let __out = aiur_fn_76(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 77u64 => { let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_77(__inp, record, io_buffer, false)?; + let __out = aiur_fn_77(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 78u64 => { let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_78(__inp, record, io_buffer, false)?; + let __out = aiur_fn_78(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 79u64 => { let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_79(__inp, record, io_buffer, false)?; + let __out = aiur_fn_79(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 80u64 => { let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_80(__inp, record, io_buffer, false)?; + let __out = aiur_fn_80(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 81u64 => { let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_81(__inp, record, io_buffer, false)?; + let __out = aiur_fn_81(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 82u64 => { let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_82(__inp, record, io_buffer, false)?; + let __out = aiur_fn_82(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 83u64 => { let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_83(__inp, record, io_buffer, false)?; + let __out = aiur_fn_83(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 84u64 => { let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_84(__inp, record, io_buffer, false)?; + let __out = aiur_fn_84(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 85u64 => { let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_85(__inp, record, io_buffer, false)?; + let __out = aiur_fn_85(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 86u64 => { let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_86(__inp, record, io_buffer, false)?; + let __out = aiur_fn_86(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 87u64 => { let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_87(__inp, record, io_buffer, false)?; + let __out = aiur_fn_87(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 88u64 => { let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_88(__inp, record, io_buffer, false)?; + let __out = aiur_fn_88(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 89u64 => { let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_89(__inp, record, io_buffer, false)?; + let __out = aiur_fn_89(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 90u64 => { let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_90(__inp, record, io_buffer, false)?; + let __out = aiur_fn_90(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 91u64 => { let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_91(__inp, record, io_buffer, false)?; + let __out = aiur_fn_91(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 92u64 => { let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_92(__inp, record, io_buffer, false)?; + let __out = aiur_fn_92(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 93u64 => { let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_93(__inp, record, io_buffer, false)?; + let __out = aiur_fn_93(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 94u64 => { let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_94(__inp, record, io_buffer, false)?; + let __out = aiur_fn_94(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 95u64 => { let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_95(__inp, record, io_buffer, false)?; + let __out = aiur_fn_95(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 96u64 => { let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_96(__inp, record, io_buffer, false)?; + let __out = aiur_fn_96(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 97u64 => { let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_97(__inp, record, io_buffer, false)?; + let __out = aiur_fn_97(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 98u64 => { let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_98(__inp, record, io_buffer, false)?; + let __out = aiur_fn_98(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 99u64 => { let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_99(__inp, record, io_buffer, false)?; + let __out = aiur_fn_99(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 100u64 => { let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_100(__inp, record, io_buffer, false)?; + let __out = aiur_fn_100(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 101u64 => { let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_101(__inp, record, io_buffer, false)?; + let __out = aiur_fn_101(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 102u64 => { let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_102(__inp, record, io_buffer, false)?; + let __out = aiur_fn_102(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 103u64 => { let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_103(__inp, record, io_buffer, false)?; + let __out = aiur_fn_103(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 104u64 => { let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_104(__inp, record, io_buffer, false)?; + let __out = aiur_fn_104(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 105u64 => { let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_105(__inp, record, io_buffer, false)?; + let __out = aiur_fn_105(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 106u64 => { let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_106(__inp, record, io_buffer, false)?; + let __out = aiur_fn_106(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 107u64 => { let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_107(__inp, record, io_buffer, false)?; + let __out = aiur_fn_107(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 108u64 => { let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_108(__inp, record, io_buffer, false)?; + let __out = aiur_fn_108(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 109u64 => { let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_109(__inp, record, io_buffer, false)?; + let __out = aiur_fn_109(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 110u64 => { let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_110(__inp, record, io_buffer, false)?; + let __out = aiur_fn_110(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 111u64 => { let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_111(__inp, record, io_buffer, false)?; + let __out = aiur_fn_111(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 112u64 => { let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_112(__inp, record, io_buffer, false)?; + let __out = aiur_fn_112(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 113u64 => { let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_113(__inp, record, io_buffer, false)?; + let __out = aiur_fn_113(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 114u64 => { let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_114(__inp, record, io_buffer, false)?; + let __out = aiur_fn_114(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 115u64 => { let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_115(__inp, record, io_buffer, false)?; + let __out = aiur_fn_115(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 116u64 => { let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_116(__inp, record, io_buffer, false)?; + let __out = aiur_fn_116(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 117u64 => { let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_117(__inp, record, io_buffer, false)?; + let __out = aiur_fn_117(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 118u64 => { let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_118(__inp, record, io_buffer, false)?; + let __out = aiur_fn_118(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 119u64 => { let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_119(__inp, record, io_buffer, false)?; + let __out = aiur_fn_119(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 120u64 => { let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_120(__inp, record, io_buffer, false)?; + let __out = aiur_fn_120(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 121u64 => { let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_121(__inp, record, io_buffer, false)?; + let __out = aiur_fn_121(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 122u64 => { let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_122(__inp, record, io_buffer, false)?; + let __out = aiur_fn_122(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 123u64 => { let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_123(__inp, record, io_buffer, false)?; + let __out = aiur_fn_123(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 124u64 => { let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_124(__inp, record, io_buffer, false)?; + let __out = aiur_fn_124(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 125u64 => { let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_125(__inp, record, io_buffer, false)?; + let __out = aiur_fn_125(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 126u64 => { let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_126(__inp, record, io_buffer, false)?; + let __out = aiur_fn_126(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 127u64 => { let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_127(__inp, record, io_buffer, false)?; + let __out = aiur_fn_127(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 128u64 => { let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_128(__inp, record, io_buffer, false)?; + let __out = aiur_fn_128(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 129u64 => { let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_129(__inp, record, io_buffer, false)?; + let __out = aiur_fn_129(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 130u64 => { let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_130(__inp, record, io_buffer, false)?; + let __out = aiur_fn_130(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 131u64 => { let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_131(__inp, record, io_buffer, false)?; + let __out = aiur_fn_131(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 132u64 => { let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_132(__inp, record, io_buffer, false)?; + let __out = aiur_fn_132(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 133u64 => { let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_133(__inp, record, io_buffer, false)?; + let __out = aiur_fn_133(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 134u64 => { let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_134(__inp, record, io_buffer, false)?; + let __out = aiur_fn_134(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 135u64 => { let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_135(__inp, record, io_buffer, false)?; + let __out = aiur_fn_135(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 136u64 => { let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_136(__inp, record, io_buffer, false)?; + let __out = aiur_fn_136(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 137u64 => { let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_137(__inp, record, io_buffer, false)?; + let __out = aiur_fn_137(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 138u64 => { let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_138(__inp, record, io_buffer, false)?; + let __out = aiur_fn_138(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 139u64 => { let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_139(__inp, record, io_buffer, false)?; + let __out = aiur_fn_139(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 140u64 => { let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_140(__inp, record, io_buffer, false)?; + let __out = aiur_fn_140(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 141u64 => { let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_141(__inp, record, io_buffer, false)?; + let __out = aiur_fn_141(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 142u64 => { let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_142(__inp, record, io_buffer, false)?; + let __out = aiur_fn_142(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 143u64 => { let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_143(__inp, record, io_buffer, false)?; + let __out = aiur_fn_143(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 144u64 => { let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_144(__inp, record, io_buffer, false)?; + let __out = aiur_fn_144(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 145u64 => { let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_145(__inp, record, io_buffer, false)?; + let __out = aiur_fn_145(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 146u64 => { let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_146(__inp, record, io_buffer, false)?; + let __out = aiur_fn_146(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 147u64 => { let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_147(__inp, record, io_buffer, false)?; + let __out = aiur_fn_147(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 148u64 => { let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_148(__inp, record, io_buffer, false)?; + let __out = aiur_fn_148(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 149u64 => { let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_149(__inp, record, io_buffer, false)?; + let __out = aiur_fn_149(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 150u64 => { let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_150(__inp, record, io_buffer, false)?; + let __out = aiur_fn_150(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 151u64 => { let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_151(__inp, record, io_buffer, false)?; + let __out = aiur_fn_151(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 152u64 => { let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_152(__inp, record, io_buffer, false)?; + let __out = aiur_fn_152(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 153u64 => { let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_153(__inp, record, io_buffer, false)?; + let __out = aiur_fn_153(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 154u64 => { let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_154(__inp, record, io_buffer, false)?; + let __out = aiur_fn_154(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 155u64 => { let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_155(__inp, record, io_buffer, false)?; + let __out = aiur_fn_155(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 156u64 => { let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_156(__inp, record, io_buffer, false)?; + let __out = aiur_fn_156(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 157u64 => { let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_157(__inp, record, io_buffer, false)?; + let __out = aiur_fn_157(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 158u64 => { let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_158(__inp, record, io_buffer, false)?; + let __out = aiur_fn_158(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 159u64 => { let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_159(__inp, record, io_buffer, false)?; + let __out = aiur_fn_159(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 160u64 => { let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_160(__inp, record, io_buffer, false)?; + let __out = aiur_fn_160(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 161u64 => { let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_161(__inp, record, io_buffer, false)?; + let __out = aiur_fn_161(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 162u64 => { let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_162(__inp, record, io_buffer, false)?; + let __out = aiur_fn_162(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 163u64 => { let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_163(__inp, record, io_buffer, false)?; + let __out = aiur_fn_163(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 164u64 => { let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_164(__inp, record, io_buffer, false)?; + let __out = aiur_fn_164(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 165u64 => { let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_165(__inp, record, io_buffer, false)?; + let __out = aiur_fn_165(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 166u64 => { let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_166(__inp, record, io_buffer, false)?; + let __out = aiur_fn_166(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 167u64 => { let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_167(__inp, record, io_buffer, false)?; + let __out = aiur_fn_167(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 168u64 => { let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_168(__inp, record, io_buffer, false)?; + let __out = aiur_fn_168(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 169u64 => { let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_169(__inp, record, io_buffer, false)?; + let __out = aiur_fn_169(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 170u64 => { let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_170(__inp, record, io_buffer, false)?; + let __out = aiur_fn_170(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 171u64 => { let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_171(__inp, record, io_buffer, false)?; + let __out = aiur_fn_171(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 172u64 => { let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_172(__inp, record, io_buffer, false)?; + let __out = aiur_fn_172(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 173u64 => { let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_173(__inp, record, io_buffer, false)?; + let __out = aiur_fn_173(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 174u64 => { let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_174(__inp, record, io_buffer, false)?; + let __out = aiur_fn_174(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 175u64 => { let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_175(__inp, record, io_buffer, false)?; + let __out = aiur_fn_175(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 176u64 => { let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_176(__inp, record, io_buffer, false)?; + let __out = aiur_fn_176(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 177u64 => { let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_177(__inp, record, io_buffer, false)?; + let __out = aiur_fn_177(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 178u64 => { let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_178(__inp, record, io_buffer, false)?; + let __out = aiur_fn_178(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 179u64 => { let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_179(__inp, record, io_buffer, false)?; + let __out = aiur_fn_179(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 180u64 => { let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_180(__inp, record, io_buffer, false)?; + let __out = aiur_fn_180(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 181u64 => { let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_181(__inp, record, io_buffer, false)?; + let __out = aiur_fn_181(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 182u64 => { let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_182(__inp, record, io_buffer, false)?; + let __out = aiur_fn_182(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 183u64 => { let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_183(__inp, record, io_buffer, false)?; + let __out = aiur_fn_183(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 184u64 => { let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_184(__inp, record, io_buffer, false)?; + let __out = aiur_fn_184(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 185u64 => { let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_185(__inp, record, io_buffer, false)?; + let __out = aiur_fn_185(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 186u64 => { let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_186(__inp, record, io_buffer, false)?; + let __out = aiur_fn_186(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 187u64 => { let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_187(__inp, record, io_buffer, false)?; + let __out = aiur_fn_187(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 188u64 => { let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_188(__inp, record, io_buffer, false)?; + let __out = aiur_fn_188(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 189u64 => { let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_189(__inp, record, io_buffer, false)?; + let __out = aiur_fn_189(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 190u64 => { let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_190(__inp, record, io_buffer, false)?; + let __out = aiur_fn_190(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 191u64 => { let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_191(__inp, record, io_buffer, false)?; + let __out = aiur_fn_191(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 192u64 => { let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_192(__inp, record, io_buffer, false)?; + let __out = aiur_fn_192(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 193u64 => { let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_193(__inp, record, io_buffer, false)?; + let __out = aiur_fn_193(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 194u64 => { let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_194(__inp, record, io_buffer, false)?; + let __out = aiur_fn_194(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 195u64 => { let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_195(__inp, record, io_buffer, false)?; + let __out = aiur_fn_195(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 196u64 => { let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_196(__inp, record, io_buffer, false)?; + let __out = aiur_fn_196(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 197u64 => { let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_197(__inp, record, io_buffer, false)?; + let __out = aiur_fn_197(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 198u64 => { let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_198(__inp, record, io_buffer, false)?; + let __out = aiur_fn_198(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 199u64 => { let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_199(__inp, record, io_buffer, false)?; + let __out = aiur_fn_199(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 200u64 => { let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_200(__inp, record, io_buffer, false)?; + let __out = aiur_fn_200(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 201u64 => { let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_201(__inp, record, io_buffer, false)?; + let __out = aiur_fn_201(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 202u64 => { let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_202(__inp, record, io_buffer, false)?; + let __out = aiur_fn_202(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 203u64 => { let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_203(__inp, record, io_buffer, false)?; + let __out = aiur_fn_203(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 204u64 => { let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_204(__inp, record, io_buffer, false)?; + let __out = aiur_fn_204(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 205u64 => { let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_205(__inp, record, io_buffer, false)?; + let __out = aiur_fn_205(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 206u64 => { let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_206(__inp, record, io_buffer, false)?; + let __out = aiur_fn_206(QueryKey::new(__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)?; + let __out = aiur_fn_207(QueryKey::new(__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)?; + let __out = aiur_fn_208(QueryKey::new(__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)?; + let __out = aiur_fn_209(QueryKey::new(__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)?; + let __out = aiur_fn_210(QueryKey::new(__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)?; + let __out = aiur_fn_211(QueryKey::new(__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)?; + let __out = aiur_fn_212(QueryKey::new(__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)?; + let __out = aiur_fn_213(QueryKey::new(__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)?; + let __out = aiur_fn_214(QueryKey::new(__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)?; + let __out = aiur_fn_215(QueryKey::new(__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)?; + let __out = aiur_fn_216(QueryKey::new(__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)?; + let __out = aiur_fn_217(QueryKey::new(__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)?; + let __out = aiur_fn_218(QueryKey::new(__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)?; + let __out = aiur_fn_219(QueryKey::new(__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)?; + let __out = aiur_fn_220(QueryKey::new(__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)?; + let __out = aiur_fn_221(QueryKey::new(__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)?; + let __out = aiur_fn_222(QueryKey::new(__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)?; + let __out = aiur_fn_223(QueryKey::new(__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)?; + let __out = aiur_fn_224(QueryKey::new(__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)?; + let __out = aiur_fn_225(QueryKey::new(__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)?; + let __out = aiur_fn_226(QueryKey::new(__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)?; + let __out = aiur_fn_227(QueryKey::new(__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)?; + let __out = aiur_fn_228(QueryKey::new(__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)?; + let __out = aiur_fn_229(QueryKey::new(__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)?; + let __out = aiur_fn_230(QueryKey::new(__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)?; + let __out = aiur_fn_231(QueryKey::new(__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)?; + let __out = aiur_fn_232(QueryKey::new(__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)?; + let __out = aiur_fn_233(QueryKey::new(__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)?; + let __out = aiur_fn_234(QueryKey::new(__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)?; + let __out = aiur_fn_235(QueryKey::new(__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)?; + let __out = aiur_fn_236(QueryKey::new(__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)?; + let __out = aiur_fn_237(QueryKey::new(__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)?; + let __out = aiur_fn_238(QueryKey::new(__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)?; + let __out = aiur_fn_239(QueryKey::new(__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)?; + let __out = aiur_fn_240(QueryKey::new(__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)?; + let __out = aiur_fn_241(QueryKey::new(__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)?; + let __out = aiur_fn_242(QueryKey::new(__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)?; + let __out = aiur_fn_243(QueryKey::new(__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)?; + let __out = aiur_fn_244(QueryKey::new(__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)?; + let __out = aiur_fn_245(QueryKey::new(__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)?; + let __out = aiur_fn_246(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 247u64 => { let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_247(__inp, record, io_buffer, false)?; + let __out = aiur_fn_247(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 248u64 => { let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_248(__inp, record, io_buffer, false)?; + let __out = aiur_fn_248(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 249u64 => { let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_249(__inp, record, io_buffer, false)?; + let __out = aiur_fn_249(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 250u64 => { let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_250(__inp, record, io_buffer, false)?; + let __out = aiur_fn_250(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 251u64 => { let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_251(__inp, record, io_buffer, false)?; + let __out = aiur_fn_251(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 252u64 => { let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_252(__inp, record, io_buffer, false)?; + let __out = aiur_fn_252(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 253u64 => { let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_253(__inp, record, io_buffer, false)?; + let __out = aiur_fn_253(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 254u64 => { let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_254(__inp, record, io_buffer, false)?; + let __out = aiur_fn_254(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 255u64 => { let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_255(__inp, record, io_buffer, false)?; + let __out = aiur_fn_255(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_256(__inp, record, io_buffer, false)?; + let __out = aiur_fn_256(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_257(__inp, record, io_buffer, false)?; + let __out = aiur_fn_257(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_258(__inp, record, io_buffer, false)?; + let __out = aiur_fn_258(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 259u64 => { let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_259(__inp, record, io_buffer, false)?; + let __out = aiur_fn_259(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 260u64 => { let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_260(__inp, record, io_buffer, false)?; + let __out = aiur_fn_260(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 261u64 => { let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_261(__inp, record, io_buffer, false)?; + let __out = aiur_fn_261(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 262u64 => { let __inp: [G; IN_262] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_262(__inp, record, io_buffer, false)?; + let __out = aiur_fn_262(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 263u64 => { let __inp: [G; IN_263] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_263(__inp, record, io_buffer, false)?; + let __out = aiur_fn_263(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 264u64 => { let __inp: [G; IN_264] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_264(__inp, record, io_buffer, false)?; + let __out = aiur_fn_264(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 265u64 => { let __inp: [G; IN_265] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_265(__inp, record, io_buffer, false)?; + let __out = aiur_fn_265(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 266u64 => { let __inp: [G; IN_266] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_266(__inp, record, io_buffer, false)?; + let __out = aiur_fn_266(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 267u64 => { let __inp: [G; IN_267] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_267(__inp, record, io_buffer, false)?; + let __out = aiur_fn_267(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 268u64 => { let __inp: [G; IN_268] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_268(__inp, record, io_buffer, false)?; + let __out = aiur_fn_268(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 269u64 => { let __inp: [G; IN_269] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_269(__inp, record, io_buffer, false)?; + let __out = aiur_fn_269(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 270u64 => { let __inp: [G; IN_270] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_270(__inp, record, io_buffer, false)?; + let __out = aiur_fn_270(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 271u64 => { let __inp: [G; IN_271] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_271(__inp, record, io_buffer, false)?; + let __out = aiur_fn_271(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 272u64 => { let __inp: [G; IN_272] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_272(__inp, record, io_buffer, false)?; + let __out = aiur_fn_272(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 273u64 => { let __inp: [G; IN_273] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_273(__inp, record, io_buffer, false)?; + let __out = aiur_fn_273(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 274u64 => { let __inp: [G; IN_274] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_274(__inp, record, io_buffer, false)?; + let __out = aiur_fn_274(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 275u64 => { let __inp: [G; IN_275] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_275(__inp, record, io_buffer, false)?; + let __out = aiur_fn_275(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 276u64 => { let __inp: [G; IN_276] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_276(__inp, record, io_buffer, false)?; + let __out = aiur_fn_276(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 277u64 => { let __inp: [G; IN_277] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_277(__inp, record, io_buffer, false)?; + let __out = aiur_fn_277(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 278u64 => { let __inp: [G; IN_278] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_278(__inp, record, io_buffer, false)?; + let __out = aiur_fn_278(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 279u64 => { let __inp: [G; IN_279] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_279(__inp, record, io_buffer, false)?; + let __out = aiur_fn_279(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 280u64 => { let __inp: [G; IN_280] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_280(__inp, record, io_buffer, false)?; + let __out = aiur_fn_280(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 281u64 => { let __inp: [G; IN_281] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_281(__inp, record, io_buffer, false)?; + let __out = aiur_fn_281(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 282u64 => { let __inp: [G; IN_282] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_282(__inp, record, io_buffer, false)?; + let __out = aiur_fn_282(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 283u64 => { let __inp: [G; IN_283] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_283(__inp, record, io_buffer, false)?; + let __out = aiur_fn_283(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 284u64 => { let __inp: [G; IN_284] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_284(__inp, record, io_buffer, false)?; + let __out = aiur_fn_284(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 285u64 => { let __inp: [G; IN_285] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_285(__inp, record, io_buffer, false)?; + let __out = aiur_fn_285(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 286u64 => { let __inp: [G; IN_286] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_286(__inp, record, io_buffer, false)?; + let __out = aiur_fn_286(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 287u64 => { let __inp: [G; IN_287] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_287(__inp, record, io_buffer, false)?; + let __out = aiur_fn_287(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 288u64 => { let __inp: [G; IN_288] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_288(__inp, record, io_buffer, false)?; + let __out = aiur_fn_288(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 289u64 => { let __inp: [G; IN_289] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_289(__inp, record, io_buffer, false)?; + let __out = aiur_fn_289(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 290u64 => { let __inp: [G; IN_290] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_290(__inp, record, io_buffer, false)?; + let __out = aiur_fn_290(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 291u64 => { let __inp: [G; IN_291] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_291(__inp, record, io_buffer, false)?; + let __out = aiur_fn_291(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 292u64 => { let __inp: [G; IN_292] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_292(__inp, record, io_buffer, false)?; + let __out = aiur_fn_292(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 293u64 => { let __inp: [G; IN_293] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_293(__inp, record, io_buffer, false)?; + let __out = aiur_fn_293(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 294u64 => { let __inp: [G; IN_294] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_294(__inp, record, io_buffer, false)?; + let __out = aiur_fn_294(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 295u64 => { let __inp: [G; IN_295] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_295(__inp, record, io_buffer, false)?; + let __out = aiur_fn_295(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 296u64 => { let __inp: [G; IN_296] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_296(__inp, record, io_buffer, false)?; + let __out = aiur_fn_296(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 297u64 => { let __inp: [G; IN_297] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_297(__inp, record, io_buffer, false)?; + let __out = aiur_fn_297(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 298u64 => { let __inp: [G; IN_298] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_298(__inp, record, io_buffer, false)?; + let __out = aiur_fn_298(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 299u64 => { let __inp: [G; IN_299] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_299(__inp, record, io_buffer, false)?; + let __out = aiur_fn_299(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 300u64 => { let __inp: [G; IN_300] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_300(__inp, record, io_buffer, false)?; + let __out = aiur_fn_300(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 301u64 => { let __inp: [G; IN_301] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_301(__inp, record, io_buffer, false)?; + let __out = aiur_fn_301(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 302u64 => { let __inp: [G; IN_302] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_302(__inp, record, io_buffer, false)?; + let __out = aiur_fn_302(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 303u64 => { let __inp: [G; IN_303] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_303(__inp, record, io_buffer, false)?; + let __out = aiur_fn_303(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 304u64 => { let __inp: [G; IN_304] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_304(__inp, record, io_buffer, false)?; + let __out = aiur_fn_304(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 305u64 => { let __inp: [G; IN_305] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_305(__inp, record, io_buffer, false)?; + let __out = aiur_fn_305(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 306u64 => { let __inp: [G; IN_306] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_306(__inp, record, io_buffer, false)?; + let __out = aiur_fn_306(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 307u64 => { let __inp: [G; IN_307] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_307(__inp, record, io_buffer, false)?; + let __out = aiur_fn_307(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 308u64 => { let __inp: [G; IN_308] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_308(__inp, record, io_buffer, false)?; + let __out = aiur_fn_308(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 309u64 => { let __inp: [G; IN_309] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_309(__inp, record, io_buffer, false)?; + let __out = aiur_fn_309(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 310u64 => { let __inp: [G; IN_310] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_310(__inp, record, io_buffer, false)?; + let __out = aiur_fn_310(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 311u64 => { let __inp: [G; IN_311] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_311(__inp, record, io_buffer, false)?; + let __out = aiur_fn_311(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 312u64 => { let __inp: [G; IN_312] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_312(__inp, record, io_buffer, false)?; + let __out = aiur_fn_312(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 313u64 => { let __inp: [G; IN_313] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_313(__inp, record, io_buffer, false)?; + let __out = aiur_fn_313(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 314u64 => { let __inp: [G; IN_314] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_314(__inp, record, io_buffer, false)?; + let __out = aiur_fn_314(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 315u64 => { let __inp: [G; IN_315] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_315(__inp, record, io_buffer, false)?; + let __out = aiur_fn_315(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 316u64 => { let __inp: [G; IN_316] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_316(__inp, record, io_buffer, false)?; + let __out = aiur_fn_316(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 317u64 => { let __inp: [G; IN_317] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_317(__inp, record, io_buffer, false)?; + let __out = aiur_fn_317(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 318u64 => { let __inp: [G; IN_318] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_318(__inp, record, io_buffer, false)?; + let __out = aiur_fn_318(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 319u64 => { let __inp: [G; IN_319] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_319(__inp, record, io_buffer, false)?; + let __out = aiur_fn_319(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 320u64 => { let __inp: [G; IN_320] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_320(__inp, record, io_buffer, false)?; + let __out = aiur_fn_320(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 321u64 => { let __inp: [G; IN_321] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_321(__inp, record, io_buffer, false)?; + let __out = aiur_fn_321(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 322u64 => { let __inp: [G; IN_322] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_322(__inp, record, io_buffer, false)?; + let __out = aiur_fn_322(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 323u64 => { let __inp: [G; IN_323] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_323(__inp, record, io_buffer, false)?; + let __out = aiur_fn_323(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 324u64 => { let __inp: [G; IN_324] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_324(__inp, record, io_buffer, false)?; + let __out = aiur_fn_324(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 325u64 => { let __inp: [G; IN_325] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_325(__inp, record, io_buffer, false)?; + let __out = aiur_fn_325(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 326u64 => { let __inp: [G; IN_326] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_326(__inp, record, io_buffer, false)?; + let __out = aiur_fn_326(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 327u64 => { let __inp: [G; IN_327] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_327(__inp, record, io_buffer, false)?; + let __out = aiur_fn_327(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 328u64 => { let __inp: [G; IN_328] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_328(__inp, record, io_buffer, false)?; + let __out = aiur_fn_328(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 329u64 => { let __inp: [G; IN_329] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_329(__inp, record, io_buffer, false)?; + let __out = aiur_fn_329(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 330u64 => { let __inp: [G; IN_330] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_330(__inp, record, io_buffer, false)?; + let __out = aiur_fn_330(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 331u64 => { let __inp: [G; IN_331] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_331(__inp, record, io_buffer, false)?; + let __out = aiur_fn_331(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 332u64 => { let __inp: [G; IN_332] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_332(__inp, record, io_buffer, false)?; + let __out = aiur_fn_332(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 333u64 => { let __inp: [G; IN_333] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_333(__inp, record, io_buffer, false)?; + let __out = aiur_fn_333(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 334u64 => { let __inp: [G; IN_334] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_334(__inp, record, io_buffer, false)?; + let __out = aiur_fn_334(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 335u64 => { let __inp: [G; IN_335] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_335(__inp, record, io_buffer, false)?; + let __out = aiur_fn_335(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 336u64 => { let __inp: [G; IN_336] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_336(__inp, record, io_buffer, false)?; + let __out = aiur_fn_336(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 337u64 => { let __inp: [G; IN_337] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_337(__inp, record, io_buffer, false)?; + let __out = aiur_fn_337(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 338u64 => { let __inp: [G; IN_338] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_338(__inp, record, io_buffer, false)?; + let __out = aiur_fn_338(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 339u64 => { let __inp: [G; IN_339] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_339(__inp, record, io_buffer, false)?; + let __out = aiur_fn_339(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 340u64 => { let __inp: [G; IN_340] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_340(__inp, record, io_buffer, false)?; + let __out = aiur_fn_340(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 341u64 => { let __inp: [G; IN_341] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_341(__inp, record, io_buffer, false)?; + let __out = aiur_fn_341(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 342u64 => { let __inp: [G; IN_342] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_342(__inp, record, io_buffer, false)?; + let __out = aiur_fn_342(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 343u64 => { let __inp: [G; IN_343] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_343(__inp, record, io_buffer, false)?; + let __out = aiur_fn_343(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 344u64 => { let __inp: [G; IN_344] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_344(__inp, record, io_buffer, false)?; + let __out = aiur_fn_344(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 345u64 => { let __inp: [G; IN_345] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_345(__inp, record, io_buffer, false)?; + let __out = aiur_fn_345(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 346u64 => { let __inp: [G; IN_346] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_346(__inp, record, io_buffer, false)?; + let __out = aiur_fn_346(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 347u64 => { let __inp: [G; IN_347] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_347(__inp, record, io_buffer, false)?; + let __out = aiur_fn_347(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 348u64 => { let __inp: [G; IN_348] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_348(__inp, record, io_buffer, false)?; + let __out = aiur_fn_348(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 349u64 => { let __inp: [G; IN_349] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_349(__inp, record, io_buffer, false)?; + let __out = aiur_fn_349(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 350u64 => { let __inp: [G; IN_350] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_350(__inp, record, io_buffer, false)?; + let __out = aiur_fn_350(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 351u64 => { let __inp: [G; IN_351] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_351(__inp, record, io_buffer, false)?; + let __out = aiur_fn_351(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 352u64 => { let __inp: [G; IN_352] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_352(__inp, record, io_buffer, false)?; + let __out = aiur_fn_352(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 353u64 => { let __inp: [G; IN_353] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_353(__inp, record, io_buffer, false)?; + let __out = aiur_fn_353(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 354u64 => { let __inp: [G; IN_354] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_354(__inp, record, io_buffer, false)?; + let __out = aiur_fn_354(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 355u64 => { let __inp: [G; IN_355] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_355(__inp, record, io_buffer, false)?; + let __out = aiur_fn_355(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 356u64 => { let __inp: [G; IN_356] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_356(__inp, record, io_buffer, false)?; + let __out = aiur_fn_356(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 357u64 => { let __inp: [G; IN_357] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_357(__inp, record, io_buffer, false)?; + let __out = aiur_fn_357(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 358u64 => { let __inp: [G; IN_358] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_358(__inp, record, io_buffer, false)?; + let __out = aiur_fn_358(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 359u64 => { let __inp: [G; IN_359] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_359(__inp, record, io_buffer, false)?; + let __out = aiur_fn_359(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 360u64 => { let __inp: [G; IN_360] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_360(__inp, record, io_buffer, false)?; + let __out = aiur_fn_360(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 361u64 => { let __inp: [G; IN_361] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_361(__inp, record, io_buffer, false)?; + let __out = aiur_fn_361(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 362u64 => { let __inp: [G; IN_362] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_362(__inp, record, io_buffer, false)?; + let __out = aiur_fn_362(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 363u64 => { let __inp: [G; IN_363] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_363(__inp, record, io_buffer, false)?; + let __out = aiur_fn_363(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 364u64 => { let __inp: [G; IN_364] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_364(__inp, record, io_buffer, false)?; + let __out = aiur_fn_364(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 365u64 => { let __inp: [G; IN_365] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_365(__inp, record, io_buffer, false)?; + let __out = aiur_fn_365(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 366u64 => { let __inp: [G; IN_366] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_366(__inp, record, io_buffer, false)?; + let __out = aiur_fn_366(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 367u64 => { let __inp: [G; IN_367] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_367(__inp, record, io_buffer, false)?; + let __out = aiur_fn_367(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 368u64 => { let __inp: [G; IN_368] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_368(__inp, record, io_buffer, false)?; + let __out = aiur_fn_368(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 369u64 => { let __inp: [G; IN_369] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_369(__inp, record, io_buffer, false)?; + let __out = aiur_fn_369(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 370u64 => { let __inp: [G; IN_370] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_370(__inp, record, io_buffer, false)?; + let __out = aiur_fn_370(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 371u64 => { let __inp: [G; IN_371] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_371(__inp, record, io_buffer, false)?; + let __out = aiur_fn_371(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 372u64 => { let __inp: [G; IN_372] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_372(__inp, record, io_buffer, false)?; + let __out = aiur_fn_372(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 373u64 => { let __inp: [G; IN_373] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_373(__inp, record, io_buffer, false)?; + let __out = aiur_fn_373(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 374u64 => { let __inp: [G; IN_374] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_374(__inp, record, io_buffer, false)?; + let __out = aiur_fn_374(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 375u64 => { let __inp: [G; IN_375] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_375(__inp, record, io_buffer, false)?; + let __out = aiur_fn_375(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 376u64 => { let __inp: [G; IN_376] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_376(__inp, record, io_buffer, false)?; + let __out = aiur_fn_376(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 377u64 => { let __inp: [G; IN_377] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_377(__inp, record, io_buffer, false)?; + let __out = aiur_fn_377(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 378u64 => { let __inp: [G; IN_378] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_378(__inp, record, io_buffer, false)?; + let __out = aiur_fn_378(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 379u64 => { let __inp: [G; IN_379] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_379(__inp, record, io_buffer, false)?; + let __out = aiur_fn_379(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 380u64 => { let __inp: [G; IN_380] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_380(__inp, record, io_buffer, false)?; + let __out = aiur_fn_380(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 381u64 => { let __inp: [G; IN_381] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_381(__inp, record, io_buffer, false)?; + let __out = aiur_fn_381(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 382u64 => { let __inp: [G; IN_382] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_382(__inp, record, io_buffer, false)?; + let __out = aiur_fn_382(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 383u64 => { let __inp: [G; IN_383] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_383(__inp, record, io_buffer, false)?; + let __out = aiur_fn_383(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 384u64 => { let __inp: [G; IN_384] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_384(__inp, record, io_buffer, false)?; + let __out = aiur_fn_384(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 385u64 => { let __inp: [G; IN_385] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_385(__inp, record, io_buffer, false)?; + let __out = aiur_fn_385(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 386u64 => { let __inp: [G; IN_386] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_386(__inp, record, io_buffer, false)?; + let __out = aiur_fn_386(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 387u64 => { let __inp: [G; IN_387] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_387(__inp, record, io_buffer, false)?; + let __out = aiur_fn_387(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 388u64 => { let __inp: [G; IN_388] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_388(__inp, record, io_buffer, false)?; + let __out = aiur_fn_388(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 389u64 => { let __inp: [G; IN_389] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_389(__inp, record, io_buffer, false)?; + let __out = aiur_fn_389(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 390u64 => { let __inp: [G; IN_390] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_390(__inp, record, io_buffer, false)?; + let __out = aiur_fn_390(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 391u64 => { let __inp: [G; IN_391] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_391(__inp, record, io_buffer, false)?; + let __out = aiur_fn_391(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 392u64 => { let __inp: [G; IN_392] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_392(__inp, record, io_buffer, false)?; + let __out = aiur_fn_392(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 393u64 => { let __inp: [G; IN_393] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_393(__inp, record, io_buffer, false)?; + let __out = aiur_fn_393(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 394u64 => { let __inp: [G; IN_394] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_394(__inp, record, io_buffer, false)?; + let __out = aiur_fn_394(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 395u64 => { let __inp: [G; IN_395] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_395(__inp, record, io_buffer, false)?; + let __out = aiur_fn_395(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 396u64 => { let __inp: [G; IN_396] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_396(__inp, record, io_buffer, false)?; + let __out = aiur_fn_396(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 397u64 => { let __inp: [G; IN_397] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_397(__inp, record, io_buffer, false)?; + let __out = aiur_fn_397(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 398u64 => { let __inp: [G; IN_398] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_398(__inp, record, io_buffer, false)?; + let __out = aiur_fn_398(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 399u64 => { let __inp: [G; IN_399] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_399(__inp, record, io_buffer, false)?; + let __out = aiur_fn_399(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 400u64 => { let __inp: [G; IN_400] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_400(__inp, record, io_buffer, false)?; + let __out = aiur_fn_400(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 401u64 => { let __inp: [G; IN_401] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_401(__inp, record, io_buffer, false)?; + let __out = aiur_fn_401(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 402u64 => { let __inp: [G; IN_402] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_402(__inp, record, io_buffer, false)?; + let __out = aiur_fn_402(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 403u64 => { let __inp: [G; IN_403] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_403(__inp, record, io_buffer, false)?; + let __out = aiur_fn_403(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 404u64 => { let __inp: [G; IN_404] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_404(__inp, record, io_buffer, false)?; + let __out = aiur_fn_404(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 405u64 => { let __inp: [G; IN_405] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_405(__inp, record, io_buffer, false)?; + let __out = aiur_fn_405(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 406u64 => { let __inp: [G; IN_406] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_406(__inp, record, io_buffer, false)?; + let __out = aiur_fn_406(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 407u64 => { let __inp: [G; IN_407] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_407(__inp, record, io_buffer, false)?; + let __out = aiur_fn_407(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 408u64 => { let __inp: [G; IN_408] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_408(__inp, record, io_buffer, false)?; + let __out = aiur_fn_408(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 409u64 => { let __inp: [G; IN_409] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_409(__inp, record, io_buffer, false)?; + let __out = aiur_fn_409(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 410u64 => { let __inp: [G; IN_410] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_410(__inp, record, io_buffer, false)?; + let __out = aiur_fn_410(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 411u64 => { let __inp: [G; IN_411] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_411(__inp, record, io_buffer, false)?; + let __out = aiur_fn_411(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 412u64 => { let __inp: [G; IN_412] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_412(__inp, record, io_buffer, false)?; + let __out = aiur_fn_412(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 413u64 => { let __inp: [G; IN_413] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_413(__inp, record, io_buffer, false)?; + let __out = aiur_fn_413(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 414u64 => { let __inp: [G; IN_414] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_414(__inp, record, io_buffer, false)?; + let __out = aiur_fn_414(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 415u64 => { let __inp: [G; IN_415] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_415(__inp, record, io_buffer, false)?; + let __out = aiur_fn_415(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 416u64 => { let __inp: [G; IN_416] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_416(__inp, record, io_buffer, false)?; + let __out = aiur_fn_416(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 417u64 => { let __inp: [G; IN_417] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_417(__inp, record, io_buffer, false)?; + let __out = aiur_fn_417(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 418u64 => { let __inp: [G; IN_418] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_418(__inp, record, io_buffer, false)?; + let __out = aiur_fn_418(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 419u64 => { let __inp: [G; IN_419] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_419(__inp, record, io_buffer, false)?; + let __out = aiur_fn_419(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 420u64 => { let __inp: [G; IN_420] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_420(__inp, record, io_buffer, false)?; + let __out = aiur_fn_420(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 421u64 => { let __inp: [G; IN_421] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_421(__inp, record, io_buffer, false)?; + let __out = aiur_fn_421(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 422u64 => { let __inp: [G; IN_422] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_422(__inp, record, io_buffer, false)?; + let __out = aiur_fn_422(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 423u64 => { let __inp: [G; IN_423] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_423(__inp, record, io_buffer, false)?; + let __out = aiur_fn_423(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 424u64 => { let __inp: [G; IN_424] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_424(__inp, record, io_buffer, false)?; + let __out = aiur_fn_424(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 425u64 => { let __inp: [G; IN_425] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_425(__inp, record, io_buffer, false)?; + let __out = aiur_fn_425(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 426u64 => { let __inp: [G; IN_426] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_426(__inp, record, io_buffer, false)?; + let __out = aiur_fn_426(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 427u64 => { let __inp: [G; IN_427] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_427(__inp, record, io_buffer, false)?; + let __out = aiur_fn_427(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 428u64 => { let __inp: [G; IN_428] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_428(__inp, record, io_buffer, false)?; + let __out = aiur_fn_428(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 429u64 => { let __inp: [G; IN_429] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_429(__inp, record, io_buffer, false)?; + let __out = aiur_fn_429(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 430u64 => { let __inp: [G; IN_430] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_430(__inp, record, io_buffer, false)?; + let __out = aiur_fn_430(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 431u64 => { let __inp: [G; IN_431] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_431(__inp, record, io_buffer, false)?; + let __out = aiur_fn_431(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 432u64 => { let __inp: [G; IN_432] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_432(__inp, record, io_buffer, false)?; + let __out = aiur_fn_432(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 433u64 => { let __inp: [G; IN_433] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_433(__inp, record, io_buffer, false)?; + let __out = aiur_fn_433(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 434u64 => { let __inp: [G; IN_434] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_434(__inp, record, io_buffer, false)?; + let __out = aiur_fn_434(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 435u64 => { let __inp: [G; IN_435] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_435(__inp, record, io_buffer, false)?; + let __out = aiur_fn_435(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 436u64 => { let __inp: [G; IN_436] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_436(__inp, record, io_buffer, false)?; + let __out = aiur_fn_436(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 437u64 => { let __inp: [G; IN_437] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_437(__inp, record, io_buffer, false)?; + let __out = aiur_fn_437(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 438u64 => { let __inp: [G; IN_438] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_438(__inp, record, io_buffer, false)?; + let __out = aiur_fn_438(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 439u64 => { let __inp: [G; IN_439] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_439(__inp, record, io_buffer, false)?; + let __out = aiur_fn_439(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 440u64 => { let __inp: [G; IN_440] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_440(__inp, record, io_buffer, false)?; + let __out = aiur_fn_440(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 441u64 => { let __inp: [G; IN_441] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_441(__inp, record, io_buffer, false)?; + let __out = aiur_fn_441(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 442u64 => { let __inp: [G; IN_442] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_442(__inp, record, io_buffer, false)?; + let __out = aiur_fn_442(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 443u64 => { let __inp: [G; IN_443] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_443(__inp, record, io_buffer, false)?; + let __out = aiur_fn_443(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 444u64 => { let __inp: [G; IN_444] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_444(__inp, record, io_buffer, false)?; + let __out = aiur_fn_444(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 445u64 => { let __inp: [G; IN_445] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_445(__inp, record, io_buffer, false)?; + let __out = aiur_fn_445(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 446u64 => { let __inp: [G; IN_446] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_446(__inp, record, io_buffer, false)?; + let __out = aiur_fn_446(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 447u64 => { let __inp: [G; IN_447] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_447(__inp, record, io_buffer, false)?; + let __out = aiur_fn_447(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 448u64 => { let __inp: [G; IN_448] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_448(__inp, record, io_buffer, false)?; + let __out = aiur_fn_448(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 449u64 => { let __inp: [G; IN_449] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_449(__inp, record, io_buffer, false)?; + let __out = aiur_fn_449(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 450u64 => { let __inp: [G; IN_450] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_450(__inp, record, io_buffer, false)?; + let __out = aiur_fn_450(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 451u64 => { let __inp: [G; IN_451] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_451(__inp, record, io_buffer, false)?; + let __out = aiur_fn_451(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 452u64 => { let __inp: [G; IN_452] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_452(__inp, record, io_buffer, false)?; + let __out = aiur_fn_452(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 453u64 => { let __inp: [G; IN_453] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_453(__inp, record, io_buffer, false)?; + let __out = aiur_fn_453(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 454u64 => { let __inp: [G; IN_454] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_454(__inp, record, io_buffer, false)?; + let __out = aiur_fn_454(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 455u64 => { let __inp: [G; IN_455] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_455(__inp, record, io_buffer, false)?; + let __out = aiur_fn_455(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 456u64 => { let __inp: [G; IN_456] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_456(__inp, record, io_buffer, false)?; + let __out = aiur_fn_456(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 457u64 => { let __inp: [G; IN_457] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_457(__inp, record, io_buffer, false)?; + let __out = aiur_fn_457(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 458u64 => { let __inp: [G; IN_458] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_458(__inp, record, io_buffer, false)?; + let __out = aiur_fn_458(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 459u64 => { let __inp: [G; IN_459] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_459(__inp, record, io_buffer, false)?; + let __out = aiur_fn_459(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 460u64 => { let __inp: [G; IN_460] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_460(__inp, record, io_buffer, false)?; + let __out = aiur_fn_460(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 461u64 => { let __inp: [G; IN_461] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_461(__inp, record, io_buffer, false)?; + let __out = aiur_fn_461(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 462u64 => { let __inp: [G; IN_462] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_462(__inp, record, io_buffer, false)?; + let __out = aiur_fn_462(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 463u64 => { let __inp: [G; IN_463] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_463(__inp, record, io_buffer, false)?; + let __out = aiur_fn_463(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 464u64 => { let __inp: [G; IN_464] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_464(__inp, record, io_buffer, false)?; + let __out = aiur_fn_464(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 465u64 => { let __inp: [G; IN_465] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_465(__inp, record, io_buffer, false)?; + let __out = aiur_fn_465(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 466u64 => { let __inp: [G; IN_466] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_466(__inp, record, io_buffer, false)?; + let __out = aiur_fn_466(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 467u64 => { let __inp: [G; IN_467] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_467(__inp, record, io_buffer, false)?; + let __out = aiur_fn_467(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 468u64 => { let __inp: [G; IN_468] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_468(__inp, record, io_buffer, false)?; + let __out = aiur_fn_468(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 469u64 => { let __inp: [G; IN_469] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_469(__inp, record, io_buffer, false)?; + let __out = aiur_fn_469(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 470u64 => { let __inp: [G; IN_470] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_470(__inp, record, io_buffer, false)?; + let __out = aiur_fn_470(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 471u64 => { let __inp: [G; IN_471] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_471(__inp, record, io_buffer, false)?; + let __out = aiur_fn_471(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 472u64 => { let __inp: [G; IN_472] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_472(__inp, record, io_buffer, false)?; + let __out = aiur_fn_472(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 473u64 => { let __inp: [G; IN_473] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_473(__inp, record, io_buffer, false)?; + let __out = aiur_fn_473(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 474u64 => { let __inp: [G; IN_474] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_474(__inp, record, io_buffer, false)?; + let __out = aiur_fn_474(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 475u64 => { let __inp: [G; IN_475] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_475(__inp, record, io_buffer, false)?; + let __out = aiur_fn_475(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 476u64 => { let __inp: [G; IN_476] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_476(__inp, record, io_buffer, false)?; + let __out = aiur_fn_476(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 477u64 => { let __inp: [G; IN_477] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_477(__inp, record, io_buffer, false)?; + let __out = aiur_fn_477(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 478u64 => { let __inp: [G; IN_478] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_478(__inp, record, io_buffer, false)?; + let __out = aiur_fn_478(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 479u64 => { let __inp: [G; IN_479] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_479(__inp, record, io_buffer, false)?; + let __out = aiur_fn_479(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 480u64 => { let __inp: [G; IN_480] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_480(__inp, record, io_buffer, false)?; + let __out = aiur_fn_480(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 481u64 => { let __inp: [G; IN_481] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_481(__inp, record, io_buffer, false)?; + let __out = aiur_fn_481(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 482u64 => { let __inp: [G; IN_482] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_482(__inp, record, io_buffer, false)?; + let __out = aiur_fn_482(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 483u64 => { let __inp: [G; IN_483] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_483(__inp, record, io_buffer, false)?; + let __out = aiur_fn_483(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 484u64 => { let __inp: [G; IN_484] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_484(__inp, record, io_buffer, false)?; + let __out = aiur_fn_484(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 485u64 => { let __inp: [G; IN_485] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_485(__inp, record, io_buffer, false)?; + let __out = aiur_fn_485(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 486u64 => { let __inp: [G; IN_486] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_486(__inp, record, io_buffer, false)?; + let __out = aiur_fn_486(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 487u64 => { let __inp: [G; IN_487] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_487(__inp, record, io_buffer, false)?; + let __out = aiur_fn_487(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 488u64 => { let __inp: [G; IN_488] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_488(__inp, record, io_buffer, false)?; + let __out = aiur_fn_488(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 489u64 => { let __inp: [G; IN_489] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_489(__inp, record, io_buffer, false)?; + let __out = aiur_fn_489(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 490u64 => { let __inp: [G; IN_490] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_490(__inp, record, io_buffer, false)?; + let __out = aiur_fn_490(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 491u64 => { let __inp: [G; IN_491] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_491(__inp, record, io_buffer, false)?; + let __out = aiur_fn_491(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 492u64 => { let __inp: [G; IN_492] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_492(__inp, record, io_buffer, false)?; + let __out = aiur_fn_492(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 493u64 => { let __inp: [G; IN_493] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_493(__inp, record, io_buffer, false)?; + let __out = aiur_fn_493(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 494u64 => { let __inp: [G; IN_494] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_494(__inp, record, io_buffer, false)?; + let __out = aiur_fn_494(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 495u64 => { let __inp: [G; IN_495] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_495(__inp, record, io_buffer, false)?; + let __out = aiur_fn_495(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 496u64 => { let __inp: [G; IN_496] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_496(__inp, record, io_buffer, false)?; + let __out = aiur_fn_496(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 497u64 => { let __inp: [G; IN_497] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_497(__inp, record, io_buffer, false)?; + let __out = aiur_fn_497(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 498u64 => { let __inp: [G; IN_498] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_498(__inp, record, io_buffer, false)?; + let __out = aiur_fn_498(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 499u64 => { let __inp: [G; IN_499] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_499(__inp, record, io_buffer, false)?; + let __out = aiur_fn_499(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 500u64 => { let __inp: [G; IN_500] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_500(__inp, record, io_buffer, false)?; + let __out = aiur_fn_500(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 501u64 => { let __inp: [G; IN_501] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_501(__inp, record, io_buffer, false)?; + let __out = aiur_fn_501(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 502u64 => { let __inp: [G; IN_502] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_502(__inp, record, io_buffer, false)?; + let __out = aiur_fn_502(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 503u64 => { let __inp: [G; IN_503] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_503(__inp, record, io_buffer, false)?; + let __out = aiur_fn_503(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 504u64 => { let __inp: [G; IN_504] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_504(__inp, record, io_buffer, false)?; + let __out = aiur_fn_504(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 505u64 => { let __inp: [G; IN_505] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_505(__inp, record, io_buffer, false)?; + let __out = aiur_fn_505(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 506u64 => { let __inp: [G; IN_506] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_506(__inp, record, io_buffer, false)?; + let __out = aiur_fn_506(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 507u64 => { let __inp: [G; IN_507] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_507(__inp, record, io_buffer, false)?; + let __out = aiur_fn_507(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 508u64 => { let __inp: [G; IN_508] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_508(__inp, record, io_buffer, false)?; + let __out = aiur_fn_508(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 509u64 => { let __inp: [G; IN_509] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_509(__inp, record, io_buffer, false)?; + let __out = aiur_fn_509(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 510u64 => { let __inp: [G; IN_510] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_510(__inp, record, io_buffer, false)?; + let __out = aiur_fn_510(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 511u64 => { let __inp: [G; IN_511] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_511(__inp, record, io_buffer, false)?; + let __out = aiur_fn_511(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 512u64 => { let __inp: [G; IN_512] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_512(__inp, record, io_buffer, false)?; + let __out = aiur_fn_512(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 513u64 => { let __inp: [G; IN_513] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_513(__inp, record, io_buffer, false)?; + let __out = aiur_fn_513(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 514u64 => { let __inp: [G; IN_514] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_514(__inp, record, io_buffer, false)?; + let __out = aiur_fn_514(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 515u64 => { let __inp: [G; IN_515] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_515(__inp, record, io_buffer, false)?; + let __out = aiur_fn_515(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 516u64 => { let __inp: [G; IN_516] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_516(__inp, record, io_buffer, false)?; + let __out = aiur_fn_516(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 517u64 => { let __inp: [G; IN_517] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_517(__inp, record, io_buffer, false)?; + let __out = aiur_fn_517(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 518u64 => { let __inp: [G; IN_518] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_518(__inp, record, io_buffer, false)?; + let __out = aiur_fn_518(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 519u64 => { let __inp: [G; IN_519] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_519(__inp, record, io_buffer, false)?; + let __out = aiur_fn_519(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 520u64 => { let __inp: [G; IN_520] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_520(__inp, record, io_buffer, false)?; + let __out = aiur_fn_520(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 521u64 => { let __inp: [G; IN_521] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_521(__inp, record, io_buffer, false)?; + let __out = aiur_fn_521(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 522u64 => { let __inp: [G; IN_522] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_522(__inp, record, io_buffer, false)?; + let __out = aiur_fn_522(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 523u64 => { let __inp: [G; IN_523] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_523(__inp, record, io_buffer, false)?; + let __out = aiur_fn_523(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 524u64 => { let __inp: [G; IN_524] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_524(__inp, record, io_buffer, false)?; + let __out = aiur_fn_524(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 525u64 => { let __inp: [G; IN_525] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_525(__inp, record, io_buffer, false)?; + let __out = aiur_fn_525(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 526u64 => { let __inp: [G; IN_526] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_526(__inp, record, io_buffer, false)?; + let __out = aiur_fn_526(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 527u64 => { let __inp: [G; IN_527] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_527(__inp, record, io_buffer, false)?; + let __out = aiur_fn_527(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 528u64 => { let __inp: [G; IN_528] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_528(__inp, record, io_buffer, false)?; + let __out = aiur_fn_528(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 529u64 => { let __inp: [G; IN_529] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_529(__inp, record, io_buffer, false)?; + let __out = aiur_fn_529(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 530u64 => { let __inp: [G; IN_530] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_530(__inp, record, io_buffer, false)?; + let __out = aiur_fn_530(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 531u64 => { let __inp: [G; IN_531] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_531(__inp, record, io_buffer, false)?; + let __out = aiur_fn_531(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 532u64 => { let __inp: [G; IN_532] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_532(__inp, record, io_buffer, false)?; + let __out = aiur_fn_532(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 533u64 => { let __inp: [G; IN_533] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_533(__inp, record, io_buffer, false)?; + let __out = aiur_fn_533(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 534u64 => { let __inp: [G; IN_534] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_534(__inp, record, io_buffer, false)?; + let __out = aiur_fn_534(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 535u64 => { let __inp: [G; IN_535] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_535(__inp, record, io_buffer, false)?; + let __out = aiur_fn_535(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 536u64 => { let __inp: [G; IN_536] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_536(__inp, record, io_buffer, false)?; + let __out = aiur_fn_536(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 537u64 => { let __inp: [G; IN_537] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_537(__inp, record, io_buffer, false)?; + let __out = aiur_fn_537(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 538u64 => { let __inp: [G; IN_538] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_538(__inp, record, io_buffer, false)?; + let __out = aiur_fn_538(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 539u64 => { let __inp: [G; IN_539] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_539(__inp, record, io_buffer, false)?; + let __out = aiur_fn_539(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 540u64 => { let __inp: [G; IN_540] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_540(__inp, record, io_buffer, false)?; + let __out = aiur_fn_540(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 541u64 => { let __inp: [G; IN_541] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_541(__inp, record, io_buffer, false)?; + let __out = aiur_fn_541(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 542u64 => { let __inp: [G; IN_542] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_542(__inp, record, io_buffer, false)?; + let __out = aiur_fn_542(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 543u64 => { let __inp: [G; IN_543] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_543(__inp, record, io_buffer, false)?; + let __out = aiur_fn_543(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 544u64 => { let __inp: [G; IN_544] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_544(__inp, record, io_buffer, false)?; + let __out = aiur_fn_544(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 545u64 => { let __inp: [G; IN_545] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_545(__inp, record, io_buffer, false)?; + let __out = aiur_fn_545(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 546u64 => { let __inp: [G; IN_546] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_546(__inp, record, io_buffer, false)?; + let __out = aiur_fn_546(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 547u64 => { let __inp: [G; IN_547] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_547(__inp, record, io_buffer, false)?; + let __out = aiur_fn_547(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 548u64 => { let __inp: [G; IN_548] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_548(__inp, record, io_buffer, false)?; + let __out = aiur_fn_548(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 549u64 => { let __inp: [G; IN_549] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_549(__inp, record, io_buffer, false)?; + let __out = aiur_fn_549(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 550u64 => { let __inp: [G; IN_550] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_550(__inp, record, io_buffer, false)?; + let __out = aiur_fn_550(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 551u64 => { let __inp: [G; IN_551] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_551(__inp, record, io_buffer, false)?; + let __out = aiur_fn_551(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 552u64 => { let __inp: [G; IN_552] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_552(__inp, record, io_buffer, false)?; + let __out = aiur_fn_552(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 553u64 => { let __inp: [G; IN_553] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_553(__inp, record, io_buffer, false)?; + let __out = aiur_fn_553(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 554u64 => { let __inp: [G; IN_554] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_554(__inp, record, io_buffer, false)?; + let __out = aiur_fn_554(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 555u64 => { let __inp: [G; IN_555] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_555(__inp, record, io_buffer, false)?; + let __out = aiur_fn_555(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 556u64 => { let __inp: [G; IN_556] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_556(__inp, record, io_buffer, false)?; + let __out = aiur_fn_556(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 557u64 => { let __inp: [G; IN_557] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_557(__inp, record, io_buffer, false)?; + let __out = aiur_fn_557(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 558u64 => { let __inp: [G; IN_558] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_558(__inp, record, io_buffer, false)?; + let __out = aiur_fn_558(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 559u64 => { let __inp: [G; IN_559] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_559(__inp, record, io_buffer, false)?; + let __out = aiur_fn_559(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 560u64 => { let __inp: [G; IN_560] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_560(__inp, record, io_buffer, false)?; + let __out = aiur_fn_560(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 561u64 => { let __inp: [G; IN_561] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_561(__inp, record, io_buffer, false)?; + let __out = aiur_fn_561(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 562u64 => { let __inp: [G; IN_562] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_562(__inp, record, io_buffer, false)?; + let __out = aiur_fn_562(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 563u64 => { let __inp: [G; IN_563] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_563(__inp, record, io_buffer, false)?; + let __out = aiur_fn_563(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 564u64 => { let __inp: [G; IN_564] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_564(__inp, record, io_buffer, false)?; + let __out = aiur_fn_564(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 565u64 => { let __inp: [G; IN_565] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_565(__inp, record, io_buffer, false)?; + let __out = aiur_fn_565(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 566u64 => { let __inp: [G; IN_566] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_566(__inp, record, io_buffer, false)?; + let __out = aiur_fn_566(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 567u64 => { let __inp: [G; IN_567] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_567(__inp, record, io_buffer, false)?; + let __out = aiur_fn_567(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 568u64 => { let __inp: [G; IN_568] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_568(__inp, record, io_buffer, false)?; + let __out = aiur_fn_568(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 569u64 => { let __inp: [G; IN_569] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_569(__inp, record, io_buffer, false)?; + let __out = aiur_fn_569(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 570u64 => { let __inp: [G; IN_570] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_570(__inp, record, io_buffer, false)?; + let __out = aiur_fn_570(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 571u64 => { let __inp: [G; IN_571] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_571(__inp, record, io_buffer, false)?; + let __out = aiur_fn_571(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 572u64 => { let __inp: [G; IN_572] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_572(__inp, record, io_buffer, false)?; + let __out = aiur_fn_572(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 573u64 => { let __inp: [G; IN_573] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_573(__inp, record, io_buffer, false)?; + let __out = aiur_fn_573(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 574u64 => { let __inp: [G; IN_574] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_574(__inp, record, io_buffer, false)?; + let __out = aiur_fn_574(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 575u64 => { let __inp: [G; IN_575] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_575(__inp, record, io_buffer, false)?; + let __out = aiur_fn_575(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 576u64 => { let __inp: [G; IN_576] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_576(__inp, record, io_buffer, false)?; + let __out = aiur_fn_576(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 577u64 => { let __inp: [G; IN_577] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_577(__inp, record, io_buffer, false)?; + let __out = aiur_fn_577(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 578u64 => { let __inp: [G; IN_578] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_578(__inp, record, io_buffer, false)?; + let __out = aiur_fn_578(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 579u64 => { let __inp: [G; IN_579] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_579(__inp, record, io_buffer, false)?; + let __out = aiur_fn_579(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 580u64 => { let __inp: [G; IN_580] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_580(__inp, record, io_buffer, false)?; + let __out = aiur_fn_580(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 581u64 => { let __inp: [G; IN_581] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_581(__inp, record, io_buffer, false)?; + let __out = aiur_fn_581(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 582u64 => { let __inp: [G; IN_582] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_582(__inp, record, io_buffer, false)?; + let __out = aiur_fn_582(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 583u64 => { let __inp: [G; IN_583] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_583(__inp, record, io_buffer, false)?; + let __out = aiur_fn_583(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 584u64 => { let __inp: [G; IN_584] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_584(__inp, record, io_buffer, false)?; + let __out = aiur_fn_584(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 585u64 => { let __inp: [G; IN_585] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_585(__inp, record, io_buffer, false)?; + let __out = aiur_fn_585(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 586u64 => { let __inp: [G; IN_586] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_586(__inp, record, io_buffer, false)?; + let __out = aiur_fn_586(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 587u64 => { let __inp: [G; IN_587] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_587(__inp, record, io_buffer, false)?; + let __out = aiur_fn_587(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 588u64 => { let __inp: [G; IN_588] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_588(__inp, record, io_buffer, false)?; + let __out = aiur_fn_588(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 589u64 => { let __inp: [G; IN_589] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_589(__inp, record, io_buffer, false)?; + let __out = aiur_fn_589(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 590u64 => { let __inp: [G; IN_590] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_590(__inp, record, io_buffer, false)?; + let __out = aiur_fn_590(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 591u64 => { let __inp: [G; IN_591] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_591(__inp, record, io_buffer, false)?; + let __out = aiur_fn_591(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 592u64 => { let __inp: [G; IN_592] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_592(__inp, record, io_buffer, false)?; + let __out = aiur_fn_592(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 593u64 => { let __inp: [G; IN_593] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_593(__inp, record, io_buffer, false)?; + let __out = aiur_fn_593(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 594u64 => { let __inp: [G; IN_594] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_594(__inp, record, io_buffer, false)?; + let __out = aiur_fn_594(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 595u64 => { let __inp: [G; IN_595] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_595(__inp, record, io_buffer, false)?; + let __out = aiur_fn_595(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 596u64 => { let __inp: [G; IN_596] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_596(__inp, record, io_buffer, false)?; + let __out = aiur_fn_596(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 597u64 => { let __inp: [G; IN_597] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_597(__inp, record, io_buffer, false)?; + let __out = aiur_fn_597(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 598u64 => { let __inp: [G; IN_598] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_598(__inp, record, io_buffer, false)?; + let __out = aiur_fn_598(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 599u64 => { let __inp: [G; IN_599] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_599(__inp, record, io_buffer, false)?; + let __out = aiur_fn_599(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 600u64 => { let __inp: [G; IN_600] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_600(__inp, record, io_buffer, false)?; + let __out = aiur_fn_600(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 601u64 => { let __inp: [G; IN_601] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_601(__inp, record, io_buffer, false)?; + let __out = aiur_fn_601(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 602u64 => { let __inp: [G; IN_602] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_602(__inp, record, io_buffer, false)?; + let __out = aiur_fn_602(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 603u64 => { let __inp: [G; IN_603] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_603(__inp, record, io_buffer, false)?; + let __out = aiur_fn_603(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 604u64 => { let __inp: [G; IN_604] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_604(__inp, record, io_buffer, false)?; + let __out = aiur_fn_604(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 605u64 => { let __inp: [G; IN_605] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_605(__inp, record, io_buffer, false)?; + let __out = aiur_fn_605(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 606u64 => { let __inp: [G; IN_606] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_606(__inp, record, io_buffer, false)?; + let __out = aiur_fn_606(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 607u64 => { let __inp: [G; IN_607] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_607(__inp, record, io_buffer, false)?; + let __out = aiur_fn_607(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 608u64 => { let __inp: [G; IN_608] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_608(__inp, record, io_buffer, false)?; + let __out = aiur_fn_608(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 609u64 => { let __inp: [G; IN_609] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_609(__inp, record, io_buffer, false)?; + let __out = aiur_fn_609(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 610u64 => { let __inp: [G; IN_610] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_610(__inp, record, io_buffer, false)?; + let __out = aiur_fn_610(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 611u64 => { let __inp: [G; IN_611] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_611(__inp, record, io_buffer, false)?; + let __out = aiur_fn_611(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 612u64 => { let __inp: [G; IN_612] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_612(__inp, record, io_buffer, false)?; + let __out = aiur_fn_612(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 613u64 => { let __inp: [G; IN_613] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_613(__inp, record, io_buffer, false)?; + let __out = aiur_fn_613(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 614u64 => { let __inp: [G; IN_614] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_614(__inp, record, io_buffer, false)?; + let __out = aiur_fn_614(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 615u64 => { let __inp: [G; IN_615] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_615(__inp, record, io_buffer, false)?; + let __out = aiur_fn_615(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 616u64 => { let __inp: [G; IN_616] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_616(__inp, record, io_buffer, false)?; + let __out = aiur_fn_616(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 617u64 => { let __inp: [G; IN_617] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_617(__inp, record, io_buffer, false)?; + let __out = aiur_fn_617(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 618u64 => { let __inp: [G; IN_618] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_618(__inp, record, io_buffer, false)?; + let __out = aiur_fn_618(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 619u64 => { let __inp: [G; IN_619] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_619(__inp, record, io_buffer, false)?; + let __out = aiur_fn_619(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 620u64 => { let __inp: [G; IN_620] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_620(__inp, record, io_buffer, false)?; + let __out = aiur_fn_620(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 621u64 => { let __inp: [G; IN_621] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_621(__inp, record, io_buffer, false)?; + let __out = aiur_fn_621(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 622u64 => { let __inp: [G; IN_622] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_622(__inp, record, io_buffer, false)?; + let __out = aiur_fn_622(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 623u64 => { let __inp: [G; IN_623] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_623(__inp, record, io_buffer, false)?; + let __out = aiur_fn_623(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 624u64 => { let __inp: [G; IN_624] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_624(__inp, record, io_buffer, false)?; + let __out = aiur_fn_624(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 625u64 => { let __inp: [G; IN_625] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_625(__inp, record, io_buffer, false)?; + let __out = aiur_fn_625(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 626u64 => { let __inp: [G; IN_626] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_626(__inp, record, io_buffer, false)?; + let __out = aiur_fn_626(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 627u64 => { let __inp: [G; IN_627] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_627(__inp, record, io_buffer, false)?; + let __out = aiur_fn_627(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 628u64 => { let __inp: [G; IN_628] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_628(__inp, record, io_buffer, false)?; + let __out = aiur_fn_628(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 629u64 => { let __inp: [G; IN_629] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_629(__inp, record, io_buffer, false)?; + let __out = aiur_fn_629(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 630u64 => { let __inp: [G; IN_630] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_630(__inp, record, io_buffer, false)?; + let __out = aiur_fn_630(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 631u64 => { let __inp: [G; IN_631] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_631(__inp, record, io_buffer, false)?; + let __out = aiur_fn_631(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 632u64 => { let __inp: [G; IN_632] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_632(__inp, record, io_buffer, false)?; + let __out = aiur_fn_632(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 633u64 => { let __inp: [G; IN_633] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_633(__inp, record, io_buffer, false)?; + let __out = aiur_fn_633(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 634u64 => { let __inp: [G; IN_634] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_634(__inp, record, io_buffer, false)?; + let __out = aiur_fn_634(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 635u64 => { let __inp: [G; IN_635] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_635(__inp, record, io_buffer, false)?; + let __out = aiur_fn_635(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 636u64 => { let __inp: [G; IN_636] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_636(__inp, record, io_buffer, false)?; + let __out = aiur_fn_636(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 637u64 => { let __inp: [G; IN_637] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_637(__inp, record, io_buffer, false)?; + let __out = aiur_fn_637(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 638u64 => { let __inp: [G; IN_638] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_638(__inp, record, io_buffer, false)?; + let __out = aiur_fn_638(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 639u64 => { let __inp: [G; IN_639] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_639(__inp, record, io_buffer, false)?; + let __out = aiur_fn_639(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 640u64 => { let __inp: [G; IN_640] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_640(__inp, record, io_buffer, false)?; + let __out = aiur_fn_640(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 641u64 => { let __inp: [G; IN_641] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_641(__inp, record, io_buffer, false)?; + let __out = aiur_fn_641(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 642u64 => { let __inp: [G; IN_642] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_642(__inp, record, io_buffer, false)?; + let __out = aiur_fn_642(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 643u64 => { let __inp: [G; IN_643] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_643(__inp, record, io_buffer, false)?; + let __out = aiur_fn_643(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 644u64 => { let __inp: [G; IN_644] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_644(__inp, record, io_buffer, false)?; + let __out = aiur_fn_644(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 645u64 => { let __inp: [G; IN_645] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_645(__inp, record, io_buffer, false)?; + let __out = aiur_fn_645(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 646u64 => { let __inp: [G; IN_646] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_646(__inp, record, io_buffer, false)?; + let __out = aiur_fn_646(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 647u64 => { let __inp: [G; IN_647] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_647(__inp, record, io_buffer, false)?; + let __out = aiur_fn_647(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 648u64 => { let __inp: [G; IN_648] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_648(__inp, record, io_buffer, false)?; + let __out = aiur_fn_648(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 649u64 => { let __inp: [G; IN_649] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_649(__inp, record, io_buffer, false)?; + let __out = aiur_fn_649(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 650u64 => { let __inp: [G; IN_650] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_650(__inp, record, io_buffer, false)?; + let __out = aiur_fn_650(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 651u64 => { let __inp: [G; IN_651] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_651(__inp, record, io_buffer, false)?; + let __out = aiur_fn_651(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 652u64 => { let __inp: [G; IN_652] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_652(__inp, record, io_buffer, false)?; + let __out = aiur_fn_652(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 653u64 => { let __inp: [G; IN_653] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_653(__inp, record, io_buffer, false)?; + let __out = aiur_fn_653(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 654u64 => { let __inp: [G; IN_654] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_654(__inp, record, io_buffer, false)?; + let __out = aiur_fn_654(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 655u64 => { let __inp: [G; IN_655] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_655(__inp, record, io_buffer, false)?; + let __out = aiur_fn_655(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 656u64 => { let __inp: [G; IN_656] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_656(__inp, record, io_buffer, false)?; + let __out = aiur_fn_656(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 657u64 => { let __inp: [G; IN_657] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_657(__inp, record, io_buffer, false)?; + let __out = aiur_fn_657(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 658u64 => { let __inp: [G; IN_658] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_658(__inp, record, io_buffer, false)?; + let __out = aiur_fn_658(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 659u64 => { let __inp: [G; IN_659] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_659(__inp, record, io_buffer, false)?; + let __out = aiur_fn_659(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 660u64 => { let __inp: [G; IN_660] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_660(__inp, record, io_buffer, false)?; + let __out = aiur_fn_660(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 661u64 => { let __inp: [G; IN_661] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_661(__inp, record, io_buffer, false)?; + let __out = aiur_fn_661(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 662u64 => { let __inp: [G; IN_662] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_662(__inp, record, io_buffer, false)?; + let __out = aiur_fn_662(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 663u64 => { let __inp: [G; IN_663] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_663(__inp, record, io_buffer, false)?; + let __out = aiur_fn_663(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 664u64 => { let __inp: [G; IN_664] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_664(__inp, record, io_buffer, false)?; + let __out = aiur_fn_664(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 665u64 => { let __inp: [G; IN_665] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_665(__inp, record, io_buffer, false)?; + let __out = aiur_fn_665(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 666u64 => { let __inp: [G; IN_666] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_666(__inp, record, io_buffer, false)?; + let __out = aiur_fn_666(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 667u64 => { let __inp: [G; IN_667] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_667(__inp, record, io_buffer, false)?; + let __out = aiur_fn_667(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 668u64 => { let __inp: [G; IN_668] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_668(__inp, record, io_buffer, false)?; + let __out = aiur_fn_668(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 669u64 => { let __inp: [G; IN_669] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_669(__inp, record, io_buffer, false)?; + let __out = aiur_fn_669(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 670u64 => { let __inp: [G; IN_670] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_670(__inp, record, io_buffer, false)?; + let __out = aiur_fn_670(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 671u64 => { let __inp: [G; IN_671] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_671(__inp, record, io_buffer, false)?; + let __out = aiur_fn_671(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 672u64 => { let __inp: [G; IN_672] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_672(__inp, record, io_buffer, false)?; + let __out = aiur_fn_672(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 673u64 => { let __inp: [G; IN_673] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_673(__inp, record, io_buffer, false)?; + let __out = aiur_fn_673(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 674u64 => { let __inp: [G; IN_674] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_674(__inp, record, io_buffer, false)?; + let __out = aiur_fn_674(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 675u64 => { let __inp: [G; IN_675] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_675(__inp, record, io_buffer, false)?; + let __out = aiur_fn_675(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 676u64 => { let __inp: [G; IN_676] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_676(__inp, record, io_buffer, false)?; + let __out = aiur_fn_676(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 677u64 => { let __inp: [G; IN_677] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_677(__inp, record, io_buffer, false)?; + let __out = aiur_fn_677(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 678u64 => { let __inp: [G; IN_678] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_678(__inp, record, io_buffer, false)?; + let __out = aiur_fn_678(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 679u64 => { let __inp: [G; IN_679] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_679(__inp, record, io_buffer, false)?; + let __out = aiur_fn_679(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 680u64 => { let __inp: [G; IN_680] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_680(__inp, record, io_buffer, false)?; + let __out = aiur_fn_680(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 681u64 => { let __inp: [G; IN_681] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_681(__inp, record, io_buffer, false)?; + let __out = aiur_fn_681(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 682u64 => { let __inp: [G; IN_682] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_682(__inp, record, io_buffer, false)?; + let __out = aiur_fn_682(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 683u64 => { let __inp: [G; IN_683] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_683(__inp, record, io_buffer, false)?; + let __out = aiur_fn_683(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 684u64 => { let __inp: [G; IN_684] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_684(__inp, record, io_buffer, false)?; + let __out = aiur_fn_684(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 685u64 => { let __inp: [G; IN_685] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_685(__inp, record, io_buffer, false)?; + let __out = aiur_fn_685(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 686u64 => { let __inp: [G; IN_686] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_686(__inp, record, io_buffer, false)?; + let __out = aiur_fn_686(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 687u64 => { let __inp: [G; IN_687] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_687(__inp, record, io_buffer, false)?; + let __out = aiur_fn_687(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 688u64 => { let __inp: [G; IN_688] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_688(__inp, record, io_buffer, false)?; + let __out = aiur_fn_688(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 689u64 => { let __inp: [G; IN_689] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_689(__inp, record, io_buffer, false)?; + let __out = aiur_fn_689(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 690u64 => { let __inp: [G; IN_690] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_690(__inp, record, io_buffer, false)?; + let __out = aiur_fn_690(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 691u64 => { let __inp: [G; IN_691] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_691(__inp, record, io_buffer, false)?; + let __out = aiur_fn_691(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 692u64 => { let __inp: [G; IN_692] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_692(__inp, record, io_buffer, false)?; + let __out = aiur_fn_692(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 693u64 => { let __inp: [G; IN_693] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_693(__inp, record, io_buffer, false)?; + let __out = aiur_fn_693(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 694u64 => { let __inp: [G; IN_694] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_694(__inp, record, io_buffer, false)?; + let __out = aiur_fn_694(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 695u64 => { let __inp: [G; IN_695] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_695(__inp, record, io_buffer, false)?; + let __out = aiur_fn_695(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 696u64 => { let __inp: [G; IN_696] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_696(__inp, record, io_buffer, false)?; + let __out = aiur_fn_696(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 697u64 => { let __inp: [G; IN_697] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_697(__inp, record, io_buffer, false)?; + let __out = aiur_fn_697(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 698u64 => { let __inp: [G; IN_698] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_698(__inp, record, io_buffer, false)?; + let __out = aiur_fn_698(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 699u64 => { let __inp: [G; IN_699] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_699(__inp, record, io_buffer, false)?; + let __out = aiur_fn_699(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 700u64 => { let __inp: [G; IN_700] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_700(__inp, record, io_buffer, false)?; + let __out = aiur_fn_700(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 701u64 => { let __inp: [G; IN_701] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_701(__inp, record, io_buffer, false)?; + let __out = aiur_fn_701(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 702u64 => { let __inp: [G; IN_702] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_702(__inp, record, io_buffer, false)?; + let __out = aiur_fn_702(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 703u64 => { let __inp: [G; IN_703] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_703(__inp, record, io_buffer, false)?; + let __out = aiur_fn_703(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 704u64 => { let __inp: [G; IN_704] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_704(__inp, record, io_buffer, false)?; + let __out = aiur_fn_704(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 705u64 => { let __inp: [G; IN_705] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_705(__inp, record, io_buffer, false)?; + let __out = aiur_fn_705(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 706u64 => { let __inp: [G; IN_706] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_706(__inp, record, io_buffer, false)?; + let __out = aiur_fn_706(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 707u64 => { let __inp: [G; IN_707] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_707(__inp, record, io_buffer, false)?; + let __out = aiur_fn_707(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 708u64 => { let __inp: [G; IN_708] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_708(__inp, record, io_buffer, false)?; + let __out = aiur_fn_708(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 709u64 => { let __inp: [G; IN_709] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_709(__inp, record, io_buffer, false)?; + let __out = aiur_fn_709(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 710u64 => { let __inp: [G; IN_710] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_710(__inp, record, io_buffer, false)?; + let __out = aiur_fn_710(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 711u64 => { let __inp: [G; IN_711] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_711(__inp, record, io_buffer, false)?; + let __out = aiur_fn_711(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 712u64 => { let __inp: [G; IN_712] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_712(__inp, record, io_buffer, false)?; + let __out = aiur_fn_712(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 713u64 => { let __inp: [G; IN_713] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_713(__inp, record, io_buffer, false)?; + let __out = aiur_fn_713(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 714u64 => { let __inp: [G; IN_714] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_714(__inp, record, io_buffer, false)?; + let __out = aiur_fn_714(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 715u64 => { let __inp: [G; IN_715] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_715(__inp, record, io_buffer, false)?; + let __out = aiur_fn_715(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 716u64 => { let __inp: [G; IN_716] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_716(__inp, record, io_buffer, false)?; + let __out = aiur_fn_716(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 717u64 => { let __inp: [G; IN_717] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_717(__inp, record, io_buffer, false)?; + let __out = aiur_fn_717(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 718u64 => { let __inp: [G; IN_718] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_718(__inp, record, io_buffer, false)?; + let __out = aiur_fn_718(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 719u64 => { let __inp: [G; IN_719] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_719(__inp, record, io_buffer, false)?; + let __out = aiur_fn_719(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 720u64 => { let __inp: [G; IN_720] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_720(__inp, record, io_buffer, false)?; + let __out = aiur_fn_720(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 721u64 => { let __inp: [G; IN_721] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_721(__inp, record, io_buffer, false)?; + let __out = aiur_fn_721(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 722u64 => { let __inp: [G; IN_722] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_722(__inp, record, io_buffer, false)?; + let __out = aiur_fn_722(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 723u64 => { let __inp: [G; IN_723] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_723(__inp, record, io_buffer, false)?; + let __out = aiur_fn_723(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 724u64 => { let __inp: [G; IN_724] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_724(__inp, record, io_buffer, false)?; + let __out = aiur_fn_724(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 725u64 => { let __inp: [G; IN_725] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_725(__inp, record, io_buffer, false)?; + let __out = aiur_fn_725(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 726u64 => { let __inp: [G; IN_726] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_726(__inp, record, io_buffer, false)?; + let __out = aiur_fn_726(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 727u64 => { let __inp: [G; IN_727] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_727(__inp, record, io_buffer, false)?; + let __out = aiur_fn_727(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 728u64 => { let __inp: [G; IN_728] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_728(__inp, record, io_buffer, false)?; + let __out = aiur_fn_728(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 729u64 => { let __inp: [G; IN_729] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_729(__inp, record, io_buffer, false)?; + let __out = aiur_fn_729(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 730u64 => { let __inp: [G; IN_730] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_730(__inp, record, io_buffer, false)?; + let __out = aiur_fn_730(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 731u64 => { let __inp: [G; IN_731] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_731(__inp, record, io_buffer, false)?; + let __out = aiur_fn_731(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 732u64 => { let __inp: [G; IN_732] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_732(__inp, record, io_buffer, false)?; + let __out = aiur_fn_732(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 733u64 => { let __inp: [G; IN_733] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_733(__inp, record, io_buffer, false)?; + let __out = aiur_fn_733(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 734u64 => { let __inp: [G; IN_734] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_734(__inp, record, io_buffer, false)?; + let __out = aiur_fn_734(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 735u64 => { let __inp: [G; IN_735] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_735(__inp, record, io_buffer, false)?; + let __out = aiur_fn_735(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 736u64 => { let __inp: [G; IN_736] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_736(__inp, record, io_buffer, false)?; + let __out = aiur_fn_736(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 737u64 => { let __inp: [G; IN_737] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_737(__inp, record, io_buffer, false)?; + let __out = aiur_fn_737(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 738u64 => { let __inp: [G; IN_738] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_738(__inp, record, io_buffer, false)?; + let __out = aiur_fn_738(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 739u64 => { let __inp: [G; IN_739] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_739(__inp, record, io_buffer, false)?; + let __out = aiur_fn_739(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 740u64 => { let __inp: [G; IN_740] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_740(__inp, record, io_buffer, false)?; + let __out = aiur_fn_740(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 741u64 => { let __inp: [G; IN_741] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_741(__inp, record, io_buffer, false)?; + let __out = aiur_fn_741(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 742u64 => { let __inp: [G; IN_742] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_742(__inp, record, io_buffer, false)?; + let __out = aiur_fn_742(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 743u64 => { let __inp: [G; IN_743] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_743(__inp, record, io_buffer, false)?; + let __out = aiur_fn_743(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 744u64 => { let __inp: [G; IN_744] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_744(__inp, record, io_buffer, false)?; + let __out = aiur_fn_744(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 745u64 => { let __inp: [G; IN_745] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_745(__inp, record, io_buffer, false)?; + let __out = aiur_fn_745(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 746u64 => { let __inp: [G; IN_746] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_746(__inp, record, io_buffer, false)?; + let __out = aiur_fn_746(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 747u64 => { let __inp: [G; IN_747] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_747(__inp, record, io_buffer, false)?; + let __out = aiur_fn_747(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 748u64 => { let __inp: [G; IN_748] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_748(__inp, record, io_buffer, false)?; + let __out = aiur_fn_748(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 749u64 => { let __inp: [G; IN_749] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_749(__inp, record, io_buffer, false)?; + let __out = aiur_fn_749(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 750u64 => { let __inp: [G; IN_750] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_750(__inp, record, io_buffer, false)?; + let __out = aiur_fn_750(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 751u64 => { let __inp: [G; IN_751] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_751(__inp, record, io_buffer, false)?; + let __out = aiur_fn_751(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 752u64 => { let __inp: [G; IN_752] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_752(__inp, record, io_buffer, false)?; + let __out = aiur_fn_752(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 753u64 => { let __inp: [G; IN_753] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_753(__inp, record, io_buffer, false)?; + let __out = aiur_fn_753(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 754u64 => { let __inp: [G; IN_754] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_754(__inp, record, io_buffer, false)?; + let __out = aiur_fn_754(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 755u64 => { let __inp: [G; IN_755] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_755(__inp, record, io_buffer, false)?; + let __out = aiur_fn_755(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 756u64 => { let __inp: [G; IN_756] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_756(__inp, record, io_buffer, false)?; + let __out = aiur_fn_756(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 757u64 => { let __inp: [G; IN_757] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_757(__inp, record, io_buffer, false)?; + let __out = aiur_fn_757(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 758u64 => { let __inp: [G; IN_758] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_758(__inp, record, io_buffer, false)?; + let __out = aiur_fn_758(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 759u64 => { let __inp: [G; IN_759] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_759(__inp, record, io_buffer, false)?; + let __out = aiur_fn_759(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 760u64 => { let __inp: [G; IN_760] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_760(__inp, record, io_buffer, false)?; + let __out = aiur_fn_760(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 761u64 => { let __inp: [G; IN_761] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_761(__inp, record, io_buffer, false)?; + let __out = aiur_fn_761(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 762u64 => { let __inp: [G; IN_762] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_762(__inp, record, io_buffer, false)?; + let __out = aiur_fn_762(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 763u64 => { let __inp: [G; IN_763] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_763(__inp, record, io_buffer, false)?; + let __out = aiur_fn_763(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 764u64 => { let __inp: [G; IN_764] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_764(__inp, record, io_buffer, false)?; + let __out = aiur_fn_764(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 765u64 => { let __inp: [G; IN_765] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_765(__inp, record, io_buffer, false)?; + let __out = aiur_fn_765(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 766u64 => { let __inp: [G; IN_766] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_766(__inp, record, io_buffer, false)?; + let __out = aiur_fn_766(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 767u64 => { let __inp: [G; IN_767] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_767(__inp, record, io_buffer, false)?; + let __out = aiur_fn_767(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 768u64 => { let __inp: [G; IN_768] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_768(__inp, record, io_buffer, false)?; + let __out = aiur_fn_768(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 769u64 => { let __inp: [G; IN_769] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_769(__inp, record, io_buffer, false)?; + let __out = aiur_fn_769(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 770u64 => { let __inp: [G; IN_770] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_770(__inp, record, io_buffer, false)?; + let __out = aiur_fn_770(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 771u64 => { let __inp: [G; IN_771] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_771(__inp, record, io_buffer, false)?; + let __out = aiur_fn_771(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 772u64 => { let __inp: [G; IN_772] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_772(__inp, record, io_buffer, false)?; + let __out = aiur_fn_772(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 773u64 => { let __inp: [G; IN_773] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_773(__inp, record, io_buffer, false)?; + let __out = aiur_fn_773(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 774u64 => { let __inp: [G; IN_774] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_774(__inp, record, io_buffer, false)?; + let __out = aiur_fn_774(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 775u64 => { let __inp: [G; IN_775] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_775(__inp, record, io_buffer, false)?; + let __out = aiur_fn_775(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 776u64 => { let __inp: [G; IN_776] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_776(__inp, record, io_buffer, false)?; + let __out = aiur_fn_776(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 777u64 => { let __inp: [G; IN_777] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_777(__inp, record, io_buffer, false)?; + let __out = aiur_fn_777(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 778u64 => { let __inp: [G; IN_778] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_778(__inp, record, io_buffer, false)?; + let __out = aiur_fn_778(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 779u64 => { let __inp: [G; IN_779] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_779(__inp, record, io_buffer, false)?; + let __out = aiur_fn_779(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 780u64 => { let __inp: [G; IN_780] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_780(__inp, record, io_buffer, false)?; + let __out = aiur_fn_780(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 781u64 => { let __inp: [G; IN_781] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_781(__inp, record, io_buffer, false)?; + let __out = aiur_fn_781(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 782u64 => { let __inp: [G; IN_782] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_782(__inp, record, io_buffer, false)?; + let __out = aiur_fn_782(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 783u64 => { let __inp: [G; IN_783] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_783(__inp, record, io_buffer, false)?; + let __out = aiur_fn_783(QueryKey::new(__inp), record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 784u64 => { + let __inp: [G; IN_784] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_784(QueryKey::new(__inp), record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 785u64 => { + let __inp: [G; IN_785] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_785(QueryKey::new(__inp), record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 786u64 => { + let __inp: [G; IN_786] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_786(QueryKey::new(__inp), record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 787u64 => { + let __inp: [G; IN_787] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_787(QueryKey::new(__inp), record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 788u64 => { + let __inp: [G; IN_788] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_788(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, _ => { diff --git a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs index 0641b6d7e..80b4531fd 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm_runner.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm_runner.rs @@ -17,7 +17,9 @@ use crate::aiur_ixvm::execute_generated; use aiur::G; use aiur::bytecode::{FunIdx, Toplevel}; +use aiur::execute::budget::ExecutionBudget; use aiur::execute::{ExecError, IOBuffer, QueryRecord}; +use std::sync::Arc; /// Mirror of `Toplevel::execute` (same return shape, same /// `entry`-flag gate), but routes execution through the codegen'd @@ -33,11 +35,25 @@ pub fn execute_ixvm( fun_idx: FunIdx, args: Vec, io_buffer: &mut IOBuffer, +) -> Result<(QueryRecord, Vec), ExecError> { + execute_ixvm_with_budget(toplevel, fun_idx, args, io_buffer, None) +} + +// Keep the same owned-input shape as AiurSystem's executor callback. +#[allow(clippy::needless_pass_by_value)] +pub fn execute_ixvm_with_budget( + toplevel: &Toplevel, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, + budget: Option>, ) -> Result<(QueryRecord, Vec), ExecError> { if !toplevel.functions[fun_idx].entry { return Err(ExecError::NotEntryFunction(fun_idx)); } - let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; + let mut record = QueryRecord::with_budget(toplevel, io_buffer, budget)?; + let output = execute_generated(fun_idx, &args, &mut record, io_buffer) + .map_err(|e| record.execution_error(e))?; + record.log_multiplicity_stats("returned"); Ok((record, output)) } diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 4fc87a632..a98533512 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -14,23 +14,25 @@ use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; use aiur::G; +use aiur::querymap::QueryKey; use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_less_than_value, bytes2_xor_split7_value, bytes2_xor_split4_value, g_inverse_value, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; const INPUT_SIZE_0: usize = 2; const IN_0: usize = 2; const OUT_0: usize = 1; fn aiur_fn_0( - inp: [G; IN_0], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_0], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + record.checkpoint(0); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __ret: [G; OUT_0] = [__v_2]; - record.function_queries[0].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[0].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -39,15 +41,16 @@ const INPUT_SIZE_1: usize = 2; const IN_1: usize = 2; const OUT_1: usize = 1; fn aiur_fn_1( - inp: [G; IN_1], + inp: QueryKey, 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(1); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -80,7 +83,7 @@ fn aiur_fn_1( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -286,13 +289,13 @@ fn aiur_fn_1( 0u64 => { let __v_227: G = G::from_u64(1); let __ret: [G; OUT_1] = [__v_227]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_227: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_227]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -300,7 +303,7 @@ fn aiur_fn_1( _ => { let __v_214: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_214]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -308,7 +311,7 @@ fn aiur_fn_1( _ => { let __v_177: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_177]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -316,7 +319,7 @@ fn aiur_fn_1( _ => { let __v_140: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_140]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -324,7 +327,7 @@ fn aiur_fn_1( _ => { let __v_103: G = G::from_u64(0); let __ret: [G; OUT_1] = [__v_103]; - record.function_queries[1].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[1].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -335,15 +338,16 @@ const INPUT_SIZE_2: usize = 2; const IN_2: usize = 2; const OUT_2: usize = 1; fn aiur_fn_2( - inp: [G; IN_2], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_2], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(2); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -376,7 +380,7 @@ fn aiur_fn_2( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -412,16 +416,16 @@ fn aiur_fn_2( let __v_66: G = (__v_2 - __v_34); match __v_66.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[1].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[1].bump_multiplicity(__i); } let __ret: [G; OUT_1] = unsafe { *(record.function_queries[1].output_at(__i).as_ptr() as *const [G; OUT_1]) }; __ret }, _ => aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[1].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[1].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[1].bump_multiplicity(__i)?; } record.function_queries[1].output_at(__i).to_array::() }, _ => aiur_fn_1(__key, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __ret: [G; OUT_2] = [__v_67]; - record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[2].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_67: G = G::from_u64(0); let __ret: [G; OUT_2] = [__v_67]; - record.function_queries[2].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[2].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -432,22 +436,23 @@ const INPUT_SIZE_3: usize = 3; const IN_3: usize = 3; const OUT_3: usize = 1; fn aiur_fn_3( - inp: [G; IN_3], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_3], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(3); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_3] = [__v_5]; - record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[3].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -455,14 +460,14 @@ fn aiur_fn_3( let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[3].bump_multiplicity(__i); } let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_0, __v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[3].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[3].bump_multiplicity(__i)?; } record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __io_read: [G; 1] = { let __idx_u64 = __v_1.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_0, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_8: G = __io_read[0]; let __v_9: G = G::from_u64(0); - let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_8, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_3] = [__v_10]; - record.function_queries[3].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[3].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -473,20 +478,21 @@ const INPUT_SIZE_4: usize = 8; const IN_4: usize = 8; const OUT_4: usize = 1; fn aiur_fn_4( - inp: [G; IN_4], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_4], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(4); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { @@ -505,13 +511,13 @@ fn aiur_fn_4( 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -519,7 +525,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -527,7 +533,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -535,7 +541,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -543,7 +549,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -551,7 +557,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -559,7 +565,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -567,7 +573,7 @@ fn aiur_fn_4( _ => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_4] = [__v_8]; - record.function_queries[4].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[4].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -578,20 +584,21 @@ const INPUT_SIZE_5: usize = 8; const IN_5: usize = 8; const OUT_5: usize = 4; fn aiur_fn_5( - inp: [G; IN_5], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_5], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(5); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_8: G = G::from_u8(__u32_bytes[0]); @@ -599,14 +606,14 @@ fn aiur_fn_5( let __v_10: G = G::from_u8(__u32_bytes[2]); let __v_11: G = G::from_u8(__u32_bytes[3]); let __v_12: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_13: G = (__v_12 * __v_12); if (__v_13 != __v_12) { return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; - record.function_queries[5].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[5].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -615,24 +622,25 @@ const INPUT_SIZE_6: usize = 12; const IN_6: usize = 12; const OUT_6: usize = 4; fn aiur_fn_6( - inp: [G; IN_6], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_6], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; + record.checkpoint(6); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_12: G = G::from_u8(__u32_bytes[0]); @@ -640,8 +648,8 @@ fn aiur_fn_6( let __v_14: G = G::from_u8(__u32_bytes[2]); let __v_15: G = G::from_u8(__u32_bytes[3]); let __v_16: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_14; let __vj = __v_15; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_12; let __vj = __v_13; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_14; let __vj = __v_15; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_17: G = G::from_u64(1); let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_u64(2); @@ -653,7 +661,7 @@ fn aiur_fn_6( return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } let __ret: [G; OUT_6] = [__v_12, __v_13, __v_14, __v_15]; - record.function_queries[6].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[6].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -662,26 +670,27 @@ const INPUT_SIZE_7: usize = 8; const IN_7: usize = 8; const OUT_7: usize = 4; fn aiur_fn_7( - inp: [G; IN_7], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_7], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) }; - let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; - let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; - let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; + record.checkpoint(7); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record)? }; + let __v_9: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record)? }; + let __v_10: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record)? }; + let __v_11: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record)? }; let __ret: [G; OUT_7] = [__v_8, __v_9, __v_10, __v_11]; - record.function_queries[7].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[7].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -690,18 +699,19 @@ const INPUT_SIZE_8: usize = 4; const IN_8: usize = 4; const OUT_8: usize = 4; fn aiur_fn_8( - inp: [G; IN_8], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_8], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(8); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __ret: [G; OUT_8] = [__v_2, __v_3, __v_0, __v_1]; - record.function_queries[8].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[8].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -710,18 +720,19 @@ const INPUT_SIZE_9: usize = 4; const IN_9: usize = 4; const OUT_9: usize = 4; fn aiur_fn_9( - inp: [G; IN_9], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_9], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(9); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __ret: [G; OUT_9] = [__v_1, __v_2, __v_3, __v_0]; - record.function_queries[9].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[9].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -730,30 +741,31 @@ const INPUT_SIZE_10: usize = 8; const IN_10: usize = 8; const OUT_10: usize = 4; fn aiur_fn_10( - inp: [G; IN_10], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_10], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record) }; + record.checkpoint(10); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor_split7(&__v_0, &__v_4) } else { bytes2_xor_split7_value(__v_0, __v_4, record)? }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor_split7(&__v_1, &__v_5) } else { bytes2_xor_split7_value(__v_1, __v_5, record)? }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor_split7(&__v_2, &__v_6) } else { bytes2_xor_split7_value(__v_2, __v_6, record)? }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor_split7(&__v_3, &__v_7) } else { bytes2_xor_split7_value(__v_3, __v_7, record)? }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_8 + __v_11); @@ -761,7 +773,7 @@ fn aiur_fn_10( let __v_18: G = (__v_12 + __v_15); let __v_19: G = (__v_14 + __v_9); let __ret: [G; OUT_10] = [__v_16, __v_17, __v_18, __v_19]; - record.function_queries[10].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[10].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -770,30 +782,31 @@ const INPUT_SIZE_11: usize = 8; const IN_11: usize = 8; const OUT_11: usize = 4; fn aiur_fn_11( - inp: [G; IN_11], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_11], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record) }; + record.checkpoint(11); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_0, &__v_4)?; Bytes2::xor_split4(&__v_0, &__v_4) } else { bytes2_xor_split4_value(__v_0, __v_4, record)? }; let __v_8: G = __b2_out.0; let __v_9: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_5)?; Bytes2::xor_split4(&__v_1, &__v_5) } else { bytes2_xor_split4_value(__v_1, __v_5, record)? }; let __v_10: G = __b2_out.0; let __v_11: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_6)?; Bytes2::xor_split4(&__v_2, &__v_6) } else { bytes2_xor_split4_value(__v_2, __v_6, record)? }; let __v_12: G = __b2_out.0; let __v_13: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_7)?; Bytes2::xor_split4(&__v_3, &__v_7) } else { bytes2_xor_split4_value(__v_3, __v_7, record)? }; let __v_14: G = __b2_out.0; let __v_15: G = __b2_out.1; let __v_16: G = (__v_10 + __v_13); @@ -801,7 +814,7 @@ fn aiur_fn_11( let __v_18: G = (__v_14 + __v_9); let __v_19: G = (__v_8 + __v_11); let __ret: [G; OUT_11] = [__v_16, __v_17, __v_18, __v_19]; - record.function_queries[11].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[11].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -810,20 +823,21 @@ const INPUT_SIZE_12: usize = 8; const IN_12: usize = 8; const OUT_12: usize = 8; fn aiur_fn_12( - inp: [G; IN_12], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_12], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(12); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; match __v_0.as_canonical_u64() { 255u64 => { match __v_1.as_canonical_u64() { @@ -849,7 +863,7 @@ fn aiur_fn_12( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -863,7 +877,7 @@ fn aiur_fn_12( let __v_15: G = G::from_u64(1); let __v_16: G = (__v_7 + __v_15); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -878,7 +892,7 @@ fn aiur_fn_12( let __v_14: G = G::from_u64(1); let __v_15: G = (__v_6 + __v_14); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -892,7 +906,7 @@ fn aiur_fn_12( let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -905,7 +919,7 @@ fn aiur_fn_12( let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -917,7 +931,7 @@ fn aiur_fn_12( let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -928,7 +942,7 @@ fn aiur_fn_12( let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); let __ret: [G; OUT_12] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -938,7 +952,7 @@ fn aiur_fn_12( let __v_9: G = G::from_u64(1); let __v_10: G = (__v_1 + __v_9); let __ret: [G; OUT_12] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -947,7 +961,7 @@ fn aiur_fn_12( let __v_8: G = G::from_u64(1); let __v_9: G = (__v_0 + __v_8); let __ret: [G; OUT_12] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; - record.function_queries[12].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[12].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -958,20 +972,21 @@ const INPUT_SIZE_13: usize = 8; const IN_13: usize = 8; const OUT_13: usize = 1; fn aiur_fn_13( - inp: [G; IN_13], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_13], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(13); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("u64 -> field: value exceeds 2^56 (top byte must be zero)".to_string()) }); @@ -995,7 +1010,7 @@ fn aiur_fn_13( let __v_25: G = (__v_10 + __v_24); let __v_26: G = (__v_0 + __v_25); let __ret: [G; OUT_13] = [__v_26]; - record.function_queries[13].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[13].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1004,20 +1019,21 @@ const INPUT_SIZE_14: usize = 8; const IN_14: usize = 8; const OUT_14: usize = 1; fn aiur_fn_14( - inp: [G; IN_14], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_14], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; + record.checkpoint(14); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(256); let __v_9: G = (__v_8 * __v_1); let __v_10: G = G::from_u64(65536); @@ -1040,7 +1056,7 @@ fn aiur_fn_14( let __v_27: G = (__v_9 + __v_26); let __v_28: G = (__v_0 + __v_27); let __ret: [G; OUT_14] = [__v_28]; - record.function_queries[14].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[14].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1049,20 +1065,21 @@ const INPUT_SIZE_15: usize = 8; const IN_15: usize = 8; const OUT_15: usize = 1; fn aiur_fn_15( - inp: [G; IN_15], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_15], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(15); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(1020); let __v_9: G = (__v_7 - __v_8); let __v_10: G = (__v_6 + __v_9); @@ -1079,7 +1096,7 @@ fn aiur_fn_15( let __v_21: G = (__v_13 * __v_20); let __v_22: G = (__v_18 - __v_21); let __ret: [G; OUT_15] = [__v_22]; - record.function_queries[15].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[15].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1088,13 +1105,14 @@ const INPUT_SIZE_16: usize = 1; const IN_16: usize = 1; const OUT_16: usize = 8; fn aiur_fn_16( - inp: [G; IN_16], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_16], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(16); + let __v_0: G = inp.values()[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_1: G = G::from_u8(__gb[0]); let __v_2: G = G::from_u8(__gb[1]); @@ -1104,10 +1122,10 @@ fn aiur_fn_16( let __v_6: G = G::from_u8(__gb[5]); let __v_7: G = G::from_u8(__gb[6]); let __v_8: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_1; let __vj = __v_2; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_3; let __vj = __v_4; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_5; let __vj = __v_6; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_7; let __vj = __v_8; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_1; let __vj = __v_2; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_3; let __vj = __v_4; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_5; let __vj = __v_6; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_7; let __vj = __v_8; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_9: G = G::from_u64(1020); let __v_10: G = (__v_8 - __v_9); let __v_11: G = (__v_7 + __v_10); @@ -1152,7 +1170,7 @@ fn aiur_fn_16( return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_45.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - record.function_queries[16].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[16].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1161,13 +1179,14 @@ const INPUT_SIZE_17: usize = 1; const IN_17: usize = 1; const OUT_17: usize = 1; fn aiur_fn_17( - inp: [G; IN_17], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_17], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(17); + let __v_0: G = inp.values()[0]; let __v_1: G = g_inverse_value(__v_0); let __v_2: G = (__v_0 * __v_1); let __v_3: G = G::from_u64(1); @@ -1183,7 +1202,7 @@ fn aiur_fn_17( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_17] = [__v_1]; - record.function_queries[17].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[17].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1192,20 +1211,21 @@ const INPUT_SIZE_18: usize = 4; const IN_18: usize = 4; const OUT_18: usize = 2; fn aiur_fn_18( - inp: [G; IN_18], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_18], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(18); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 + __v_2); let __v_5: G = (__v_1 + __v_3); let __ret: [G; OUT_18] = [__v_4, __v_5]; - record.function_queries[18].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[18].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1214,20 +1234,21 @@ const INPUT_SIZE_19: usize = 4; const IN_19: usize = 4; const OUT_19: usize = 2; fn aiur_fn_19( - inp: [G; IN_19], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_19], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(19); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = (__v_1 - __v_3); let __ret: [G; OUT_19] = [__v_4, __v_5]; - record.function_queries[19].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[19].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1236,20 +1257,21 @@ const INPUT_SIZE_20: usize = 2; const IN_20: usize = 2; const OUT_20: usize = 2; fn aiur_fn_20( - inp: [G; IN_20], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_20], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(20); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(0); let __v_3: G = (__v_2 - __v_0); let __v_4: G = G::from_u64(0); let __v_5: G = (__v_4 - __v_1); let __ret: [G; OUT_20] = [__v_3, __v_5]; - record.function_queries[20].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[20].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1258,16 +1280,17 @@ const INPUT_SIZE_21: usize = 4; const IN_21: usize = 4; const OUT_21: usize = 2; fn aiur_fn_21( - inp: [G; IN_21], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_21], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(21); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_1 * __v_3); @@ -1277,7 +1300,7 @@ fn aiur_fn_21( let __v_10: G = (__v_1 * __v_2); let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_21] = [__v_8, __v_11]; - record.function_queries[21].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[21].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1286,14 +1309,15 @@ const INPUT_SIZE_22: usize = 2; const IN_22: usize = 2; const OUT_22: usize = 2; fn aiur_fn_22( - inp: [G; IN_22], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_22], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(22); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = (__v_0 * __v_0); let __v_3: G = G::from_u64(7); let __v_4: G = (__v_1 * __v_1); @@ -1318,7 +1342,7 @@ fn aiur_fn_22( let __v_17: G = (__v_16 - __v_1); let __v_18: G = (__v_17 * __v_7); let __ret: [G; OUT_22] = [__v_15, __v_18]; - record.function_queries[22].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[22].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1327,16 +1351,17 @@ const INPUT_SIZE_23: usize = 4; const IN_23: usize = 4; const OUT_23: usize = 2; fn aiur_fn_23( - inp: [G; IN_23], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_23], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(23); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_2 * __v_2); let __v_5: G = G::from_u64(7); let __v_6: G = (__v_3 * __v_3); @@ -1369,7 +1394,7 @@ fn aiur_fn_23( let __v_27: G = (__v_1 * __v_17); let __v_28: G = (__v_26 + __v_27); let __ret: [G; OUT_23] = [__v_25, __v_28]; - record.function_queries[23].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[23].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1378,23 +1403,24 @@ const INPUT_SIZE_24: usize = 4; const IN_24: usize = 4; const OUT_24: usize = 1; fn aiur_fn_24( - inp: [G; IN_24], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_24], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(24); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = (__v_0 - __v_2); let __v_5: G = G::from_bool((__v_4 == G::ZERO)); let __v_6: G = (__v_1 - __v_3); let __v_7: G = G::from_bool((__v_6 == G::ZERO)); let __v_8: G = (__v_5 * __v_7); let __ret: [G; OUT_24] = [__v_8]; - record.function_queries[24].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[24].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1403,30 +1429,31 @@ const INPUT_SIZE_25: usize = 1; const IN_25: usize = 1; const OUT_25: usize = 2; fn aiur_fn_25( - inp: [G; IN_25], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_25], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(25); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_25] = [__v_2, __v_3]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_25] = [__v_4, __v_7]; - record.function_queries[25].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[25].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -1440,39 +1467,40 @@ const INPUT_SIZE_26: usize = 1; const IN_26: usize = 1; const OUT_26: usize = 9; fn aiur_fn_26( - inp: [G; IN_26], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_26], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + record.checkpoint(26); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_26] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; - record.function_queries[26].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[26].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1481,14 +1509,15 @@ const INPUT_SIZE_27: usize = 1; const IN_27: usize = 1; const OUT_27: usize = 2; fn aiur_fn_27( - inp: [G; IN_27], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_27], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; + record.checkpoint(27); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[26].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i)?; } record.function_queries[26].output_at(__i).to_array::() }, _ => aiur_fn_26(__key, 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]; @@ -1498,10 +1527,10 @@ fn aiur_fn_27( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_27] = [__v_10, __v_9]; - record.function_queries[27].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[27].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1510,20 +1539,21 @@ const INPUT_SIZE_28: usize = 1; const IN_28: usize = 1; const OUT_28: usize = 2; fn aiur_fn_28( - inp: [G; IN_28], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_28], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(28); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 1] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 1)?; let __arr: [G; 1] = __data[..1].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_0 + __v_3); let __ret: [G; OUT_28] = [__v_2, __v_4]; - record.function_queries[28].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[28].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1532,13 +1562,14 @@ const INPUT_SIZE_29: usize = 1; const IN_29: usize = 1; const OUT_29: usize = 9; fn aiur_fn_29( - inp: [G; IN_29], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_29], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(29); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __io_read: [G; 8] = { let __idx_u64 = __v_0.as_canonical_u64(); let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?; let __data = io_buffer.read(__v_1, __idx, 8)?; let __arr: [G; 8] = __data[..8].try_into().unwrap(); __arr }; let __v_2: G = __io_read[0]; @@ -1552,7 +1583,7 @@ fn aiur_fn_29( let __v_10: G = G::from_u64(8); let __v_11: G = (__v_0 + __v_10); let __ret: [G; OUT_29] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11]; - record.function_queries[29].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[29].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1561,14 +1592,15 @@ const INPUT_SIZE_30: usize = 1; const IN_30: usize = 1; const OUT_30: usize = 2; fn aiur_fn_30( - inp: [G; IN_30], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_30], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + record.checkpoint(30); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1578,10 +1610,10 @@ fn aiur_fn_30( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_30] = [__v_10, __v_9]; - record.function_queries[30].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[30].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1590,14 +1622,15 @@ const INPUT_SIZE_31: usize = 1; const IN_31: usize = 1; const OUT_31: usize = 3; fn aiur_fn_31( - inp: [G; IN_31], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_31], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + record.checkpoint(31); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1607,7 +1640,7 @@ fn aiur_fn_31( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1660,7 +1693,7 @@ fn aiur_fn_31( let __v_59: G = (__v_41 + __v_58); let __v_60: G = (__v_10 + __v_59); let __ret: [G; OUT_31] = [__v_39, __v_60, __v_18]; - record.function_queries[31].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[31].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1669,14 +1702,15 @@ const INPUT_SIZE_32: usize = 1; const IN_32: usize = 1; const OUT_32: usize = 33; fn aiur_fn_32( - inp: [G; IN_32], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_32], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + record.checkpoint(32); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1686,7 +1720,7 @@ fn aiur_fn_32( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_9]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1696,7 +1730,7 @@ fn aiur_fn_32( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_18]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1706,7 +1740,7 @@ fn aiur_fn_32( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_27]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1717,7 +1751,7 @@ fn aiur_fn_32( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[32].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[32].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1726,21 +1760,22 @@ const INPUT_SIZE_33: usize = 1; const IN_33: usize = 1; const OUT_33: usize = 2; fn aiur_fn_33( - inp: [G; IN_33], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_33], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(33); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_33] = [__v_3, __v_4]; - record.function_queries[33].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[33].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1749,36 +1784,37 @@ const INPUT_SIZE_34: usize = 2; const IN_34: usize = 2; const OUT_34: usize = 2; fn aiur_fn_34( - inp: [G; IN_34], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_34], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(34); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_34] = [__v_4, __v_0]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_34] = [__v_9, __v_7]; - record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[34].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1789,21 +1825,22 @@ const INPUT_SIZE_35: usize = 1; const IN_35: usize = 1; const OUT_35: usize = 2; fn aiur_fn_35( - inp: [G; IN_35], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_35], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(35); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_35] = [__v_3, __v_4]; - record.function_queries[35].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[35].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1812,25 +1849,26 @@ const INPUT_SIZE_36: usize = 2; const IN_36: usize = 2; const OUT_36: usize = 2; fn aiur_fn_36( - inp: [G; IN_36], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_36], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(36); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_4, __v_0]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1842,13 +1880,13 @@ fn aiur_fn_36( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[36].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i)?; } record.function_queries[36].output_at(__i).to_array::() }, _ => aiur_fn_36(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_36] = [__v_16, __v_14]; - record.function_queries[36].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[36].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1859,21 +1897,22 @@ const INPUT_SIZE_37: usize = 1; const IN_37: usize = 1; const OUT_37: usize = 2; fn aiur_fn_37( - inp: [G; IN_37], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_37], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(37); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_37] = [__v_3, __v_4]; - record.function_queries[37].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[37].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -1882,25 +1921,26 @@ const INPUT_SIZE_38: usize = 2; const IN_38: usize = 2; const OUT_38: usize = 2; fn aiur_fn_38( - inp: [G; IN_38], + inp: QueryKey, 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 __v_1: G = inp[1]; + record.checkpoint(38); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_4, __v_0]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1910,7 +1950,7 @@ fn aiur_fn_38( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -1964,13 +2004,13 @@ fn aiur_fn_38( let __v_61: G = (__v_11 + __v_60); let __v_62: G = G::from_u64(1); let __v_63: G = (__v_1 - __v_62); - let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_19, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[38].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i)?; } record.function_queries[38].output_at(__i).to_array::() }, _ => aiur_fn_38(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 4] = [__v_66, __v_40, __v_61, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_38] = [__v_67, __v_65]; - record.function_queries[38].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[38].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -1981,21 +2021,22 @@ const INPUT_SIZE_39: usize = 1; const IN_39: usize = 1; const OUT_39: usize = 2; fn aiur_fn_39( - inp: [G; IN_39], + inp: QueryKey, 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 __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(39); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[40].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i)?; } record.function_queries[40].output_at(__i).to_array::() }, _ => aiur_fn_40(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_39] = [__v_3, __v_4]; - record.function_queries[39].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[39].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2004,25 +2045,26 @@ const INPUT_SIZE_40: usize = 2; const IN_40: usize = 2; const OUT_40: usize = 2; fn aiur_fn_40( - inp: [G; IN_40], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_40], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(40); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_4, __v_0]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2032,7 +2074,7 @@ fn aiur_fn_40( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2042,7 +2084,7 @@ fn aiur_fn_40( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_19]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_19]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2052,7 +2094,7 @@ fn aiur_fn_40( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_28]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2064,14 +2106,14 @@ fn aiur_fn_40( let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_37, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[40].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i)?; } record.function_queries[40].output_at(__i).to_array::() }, _ => aiur_fn_40(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_40] = [__v_44, __v_41]; - record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[40].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2082,21 +2124,22 @@ const INPUT_SIZE_41: usize = 1; const IN_41: usize = 1; const OUT_41: usize = 2; fn aiur_fn_41( - inp: [G; IN_41], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_41], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(41); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_41] = [__v_3, __v_4]; - record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[41].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2105,36 +2148,37 @@ const INPUT_SIZE_42: usize = 2; const IN_42: usize = 2; const OUT_42: usize = 2; fn aiur_fn_42( - inp: [G; IN_42], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_42], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(42); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_42] = [__v_4, __v_0]; - record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[42].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_42] = [__v_9, __v_7]; - record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[42].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2145,21 +2189,22 @@ const INPUT_SIZE_43: usize = 1; const IN_43: usize = 1; const OUT_43: usize = 2; fn aiur_fn_43( - inp: [G; IN_43], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_43], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(43); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_43] = [__v_3, __v_4]; - record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[43].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2168,39 +2213,40 @@ const INPUT_SIZE_44: usize = 2; const IN_44: usize = 2; const OUT_44: usize = 2; fn aiur_fn_44( - inp: [G; IN_44], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_44], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(44); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_44] = [__v_4, __v_0]; - record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[44].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[42].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i)?; } record.function_queries[42].output_at(__i).to_array::() }, _ => aiur_fn_42(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_44] = [__v_11, __v_9]; - record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[44].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2211,21 +2257,22 @@ const INPUT_SIZE_45: usize = 1; const IN_45: usize = 1; const OUT_45: usize = 2; fn aiur_fn_45( - inp: [G; IN_45], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_45], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(45); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, 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]; - record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[45].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2234,36 +2281,37 @@ const INPUT_SIZE_46: usize = 2; const IN_46: usize = 2; const OUT_46: usize = 2; fn aiur_fn_46( - inp: [G; IN_46], + inp: QueryKey, 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]; + record.checkpoint(46); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_46] = [__v_4, __v_0]; - record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[46].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_46] = [__v_9, __v_7]; - record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[46].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2274,21 +2322,22 @@ const INPUT_SIZE_47: usize = 1; const IN_47: usize = 1; const OUT_47: usize = 2; fn aiur_fn_47( - inp: [G; IN_47], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_47], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(47); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_47] = [__v_3, __v_4]; - record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[47].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2297,36 +2346,37 @@ const INPUT_SIZE_48: usize = 2; const IN_48: usize = 2; const OUT_48: usize = 2; fn aiur_fn_48( - inp: [G; IN_48], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_48], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(48); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_48] = [__v_4, __v_0]; - record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[48].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[45].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i)?; } record.function_queries[45].output_at(__i).to_array::() }, _ => aiur_fn_45(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[48].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i)?; } record.function_queries[48].output_at(__i).to_array::() }, _ => aiur_fn_48(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_48] = [__v_9, __v_7]; - record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[48].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2337,18 +2387,19 @@ const INPUT_SIZE_49: usize = 1; const IN_49: usize = 1; const OUT_49: usize = 2; fn aiur_fn_49( - inp: [G; IN_49], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_49], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + record.checkpoint(49); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_49] = [__v_1, __v_2]; - record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[49].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2357,21 +2408,22 @@ const INPUT_SIZE_50: usize = 1; const IN_50: usize = 1; const OUT_50: usize = 2; fn aiur_fn_50( - inp: [G; IN_50], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_50], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(50); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_50] = [__v_3, __v_4]; - record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[50].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2380,36 +2432,37 @@ const INPUT_SIZE_51: usize = 2; const IN_51: usize = 2; const OUT_51: usize = 2; fn aiur_fn_51( - inp: [G; IN_51], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_51], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(51); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_51] = [__v_4, __v_0]; - record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[51].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_51] = [__v_9, __v_7]; - record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[51].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2420,24 +2473,25 @@ const INPUT_SIZE_52: usize = 1; const IN_52: usize = 1; const OUT_52: usize = 4; fn aiur_fn_52( - inp: [G; IN_52], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_52], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + record.checkpoint(52); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_52] = [__v_1, __v_3, __v_5, __v_6]; - record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[52].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2446,24 +2500,25 @@ const INPUT_SIZE_53: usize = 1; const IN_53: usize = 1; const OUT_53: usize = 3; fn aiur_fn_53( - inp: [G; IN_53], + inp: QueryKey, 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_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(53); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __ret: [G; OUT_53] = [__v_3, __v_5, __v_6]; - record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[53].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2472,21 +2527,22 @@ const INPUT_SIZE_54: usize = 1; const IN_54: usize = 1; const OUT_54: usize = 2; fn aiur_fn_54( - inp: [G; IN_54], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_54], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(54); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, 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]; - record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[54].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2495,42 +2551,43 @@ const INPUT_SIZE_55: usize = 2; const IN_55: usize = 2; const OUT_55: usize = 2; fn aiur_fn_55( - inp: [G; IN_55], + inp: QueryKey, 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]; + record.checkpoint(55); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_55] = [__v_4, __v_0]; - record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[55].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[44].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i)?; } record.function_queries[44].output_at(__i).to_array::() }, _ => aiur_fn_44(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_4, __v_6, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_55] = [__v_13, __v_11]; - record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[55].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2541,27 +2598,28 @@ const INPUT_SIZE_56: usize = 1; const IN_56: usize = 1; const OUT_56: usize = 4; fn aiur_fn_56( - inp: [G; IN_56], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_56], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + record.checkpoint(56); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __ret: [G; OUT_56] = [__v_1, __v_5, __v_7, __v_8]; - record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[56].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2570,21 +2628,22 @@ const INPUT_SIZE_57: usize = 1; const IN_57: usize = 1; const OUT_57: usize = 2; fn aiur_fn_57( - inp: [G; IN_57], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_57], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(57); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_57] = [__v_3, __v_4]; - record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[57].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2593,45 +2652,46 @@ const INPUT_SIZE_58: usize = 2; const IN_58: usize = 2; const OUT_58: usize = 2; fn aiur_fn_58( - inp: [G; IN_58], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_58], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(58); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 5] = [__v_2, __v_3, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_58] = [__v_4, __v_0]; - record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[58].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[46].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i)?; } record.function_queries[46].output_at(__i).to_array::() }, _ => aiur_fn_46(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_9, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 5] = [__v_14, __v_2, __v_6, __v_8, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_58] = [__v_15, __v_13]; - record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[58].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2642,38 +2702,39 @@ const INPUT_SIZE_59: usize = 1; const IN_59: usize = 1; const OUT_59: usize = 14; fn aiur_fn_59( - inp: [G; IN_59], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_59], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(59); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_8, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_16]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -2684,7 +2745,7 @@ fn aiur_fn_59( let __v_24: G = __r_arr[7]; let __v_25: G = __r_arr[8]; let __ret: [G; OUT_59] = [__v_3, __v_5, __v_9, __v_13, __v_15, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[59].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2693,14 +2754,15 @@ const INPUT_SIZE_60: usize = 1; const IN_60: usize = 1; const OUT_60: usize = 3; fn aiur_fn_60( - inp: [G; IN_60], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_60], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __cu = true; let __hit = record.function_queries[28].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_28] = unsafe { *(record.function_queries[28].output_at(__i).as_ptr() as *const [G; OUT_28]) }; __ret }, _ => aiur_fn_28(__args, record, io_buffer, __cu)? } }; + record.checkpoint(60); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[28].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[28].output_at(__i).to_array::() }, _ => aiur_fn_28(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -2708,16 +2770,16 @@ fn aiur_fn_60( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); let __ret: [G; OUT_60] = [__v_3, __v_4, __v_2]; - record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[60].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __ret: [G; OUT_60] = [__v_5, __v_3, __v_4]; - record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[60].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -2728,62 +2790,63 @@ const INPUT_SIZE_61: usize = 1; const IN_61: usize = 1; const OUT_61: usize = 25; fn aiur_fn_61( - inp: [G; IN_61], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_61], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + record.checkpoint(61); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_14, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_14, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_18, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_24, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_24, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_28, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_28, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_32]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_32]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __v_35: G = __r_arr[2]; @@ -2793,21 +2856,21 @@ fn aiur_fn_61( let __v_39: G = __r_arr[6]; let __v_40: G = __r_arr[7]; let __v_41: G = __r_arr[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[60].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i)?; } record.function_queries[60].output_at(__i).to_array::() }, _ => aiur_fn_60(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __ret: [G; OUT_61] = [__v_3, __v_5, __v_7, __v_9, __v_11, __v_15, __v_19, __v_21, __v_25, __v_29, __v_31, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_42, __v_44, __v_45, __v_47, __v_49, __v_50]; - record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[61].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2816,16 +2879,17 @@ const INPUT_SIZE_62: usize = 4; const IN_62: usize = 4; const OUT_62: usize = 1; fn aiur_fn_62( - inp: [G; IN_62], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_62], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(62); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(256); let __v_5: G = (__v_4 * __v_1); let __v_6: G = G::from_u64(65536); @@ -2836,7 +2900,7 @@ fn aiur_fn_62( let __v_11: G = (__v_5 + __v_10); let __v_12: G = (__v_0 + __v_11); let __ret: [G; OUT_62] = [__v_12]; - record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[62].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2845,44 +2909,45 @@ const INPUT_SIZE_63: usize = 32; const IN_63: usize = 32; const OUT_63: usize = 8; fn aiur_fn_63( - inp: [G; IN_63], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_63], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(63); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; let __v_32: G = G::from_u64(256); let __v_33: G = (__v_32 * __v_1); let __v_34: G = G::from_u64(65536); @@ -2956,7 +3021,7 @@ fn aiur_fn_63( let __v_102: G = (__v_96 + __v_101); let __v_103: G = (__v_28 + __v_102); let __ret: [G; OUT_63] = [__v_40, __v_49, __v_58, __v_67, __v_76, __v_85, __v_94, __v_103]; - record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[63].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -2965,13 +3030,14 @@ const INPUT_SIZE_64: usize = 1; const IN_64: usize = 1; const OUT_64: usize = 32; fn aiur_fn_64( - inp: [G; IN_64], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_64], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(64); + let __v_0: G = inp.values()[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); @@ -3006,7 +3072,7 @@ fn aiur_fn_64( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -3017,14 +3083,14 @@ fn aiur_fn_64( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3058,7 +3124,7 @@ fn aiur_fn_64( let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; let __ret: [G; OUT_64] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; - record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[64].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -3067,13 +3133,14 @@ const INPUT_SIZE_65: usize = 1; const IN_65: usize = 1; const OUT_65: usize = 1; fn aiur_fn_65( - inp: [G; IN_65], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_65], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(65); + let __v_0: G = inp.values()[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); @@ -3108,7 +3175,7 @@ fn aiur_fn_65( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -3119,14 +3186,14 @@ fn aiur_fn_65( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); - let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3159,9 +3226,9 @@ fn aiur_fn_65( let __v_81: G = __r_arr[29]; let __v_82: G = __r_arr[30]; let __v_83: G = __r_arr[31]; - let __v_84: G = { let __values: [G; 32] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_65] = [__v_84]; - record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[65].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -3170,47 +3237,48 @@ const INPUT_SIZE_66: usize = 34; const IN_66: usize = 34; const OUT_66: usize = 34; fn aiur_fn_66( - inp: [G; IN_66], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_66], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + record.checkpoint(66); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -3249,12 +3317,12 @@ fn aiur_fn_66( 1u64 => { let __v_68: G = G::from_u64(1); let __ret: [G; OUT_66] = [__v_68, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_0]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[66].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i)?; } record.function_queries[66].output_at(__i).to_array::() }, _ => aiur_fn_66(__key, 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]; @@ -3293,7 +3361,7 @@ fn aiur_fn_66( 0u64 => { let __v_103: G = G::from_u64(1); let __ret: [G; OUT_66] = [__v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_102]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -3331,7 +3399,7 @@ fn aiur_fn_66( let __v_134: G = G::from_u64(205); let __v_135: G = G::from_u64(224); let __v_136: G = G::from_u64(91); - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -3402,7 +3470,7 @@ fn aiur_fn_66( let __v_202: G = G::from_u64(0); let __v_203: G = G::from_u64(0); let __v_204: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_204, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_198, __v_199, __v_200, __v_172, __v_201, __v_202, __v_203, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -3438,9 +3506,9 @@ fn aiur_fn_66( let __v_237: G = G::from_u64(0); let __v_238: G = G::from_u64(0); let __v_239: G = G::from_u64(0); - let __v_240: G = { let __values: [G; 34] = [__v_239, __v_102, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_66] = [__v_237, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_238, __v_240]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3476,7 +3544,7 @@ fn aiur_fn_66( let __v_200: G = G::from_u64(0); let __v_201: G = G::from_u64(0); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_202, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_196, __v_197, __v_198, __v_103, __v_199, __v_200, __v_201, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -3512,9 +3580,9 @@ fn aiur_fn_66( let __v_235: G = G::from_u64(0); let __v_236: G = G::from_u64(0); let __v_237: G = G::from_u64(0); - let __v_238: G = { let __values: [G; 34] = [__v_237, __v_102, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_66] = [__v_235, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_236, __v_238]; - record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[66].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -3535,14 +3603,15 @@ const INPUT_SIZE_67: usize = 1; const IN_67: usize = 1; const OUT_67: usize = 32; fn aiur_fn_67( - inp: [G; IN_67], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_67], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + record.checkpoint(67); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -3579,7 +3648,7 @@ fn aiur_fn_67( let __v_34: G = __loaded[33]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<34>() }; let __v_35: G = __loaded[0]; let __v_36: G = __loaded[1]; let __v_37: G = __loaded[2]; @@ -3617,12 +3686,12 @@ fn aiur_fn_67( match __v_35.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_69]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[66].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i)?; } record.function_queries[66].output_at(__i).to_array::() }, _ => aiur_fn_66(__key, 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]; @@ -3659,7 +3728,7 @@ fn aiur_fn_67( let __v_103: G = __r_arr[33]; match __v_70.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_103]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_103]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3693,13 +3762,13 @@ fn aiur_fn_67( let __v_134: G = __r_arr[30]; let __v_135: G = __r_arr[31]; let __ret: [G; OUT_67] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -3733,7 +3802,7 @@ fn aiur_fn_67( let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; let __ret: [G; OUT_67] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; - record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[67].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3754,40 +3823,41 @@ const INPUT_SIZE_68: usize = 7; const IN_68: usize = 7; const OUT_68: usize = 1; fn aiur_fn_68( - inp: [G; IN_68], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_68], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(68); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[71].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i)?; } record.function_queries[71].output_at(__i).to_array::() }, _ => aiur_fn_71(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_10]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; match __v_2.as_canonical_u64() { 63u64 => { - let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[72].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i)?; } record.function_queries[72].output_at(__i).to_array::() }, _ => aiur_fn_72(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_12]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -3795,10 +3865,10 @@ fn aiur_fn_68( let __v_13: G = (__v_2 + __v_12); let __v_14: G = G::from_u64(1); let __v_15: G = (__v_3 + __v_14); - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __ret: [G; OUT_68] = [__v_16]; - record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[68].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -3814,399 +3884,400 @@ const INPUT_SIZE_69: usize = 1; const IN_69: usize = 1; const OUT_69: usize = 64; fn aiur_fn_69( - inp: [G; IN_69], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_69], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(69); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_97: G = __loaded[0]; let __v_98: G = __loaded[1]; let __v_99: G = __loaded[2]; match __v_97.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_100: G = __loaded[0]; let __v_101: G = __loaded[1]; let __v_102: G = __loaded[2]; match __v_100.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_127: G = __loaded[0]; let __v_128: G = __loaded[1]; let __v_129: G = __loaded[2]; match __v_127.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_130: G = __loaded[0]; let __v_131: G = __loaded[1]; let __v_132: G = __loaded[2]; match __v_130.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_133: G = __loaded[0]; let __v_134: G = __loaded[1]; let __v_135: G = __loaded[2]; match __v_133.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_136: G = __loaded[0]; let __v_137: G = __loaded[1]; let __v_138: G = __loaded[2]; match __v_136.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_139: G = __loaded[0]; let __v_140: G = __loaded[1]; let __v_141: G = __loaded[2]; match __v_139.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_142: G = __loaded[0]; let __v_143: G = __loaded[1]; let __v_144: G = __loaded[2]; match __v_142.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_145: G = __loaded[0]; let __v_146: G = __loaded[1]; let __v_147: G = __loaded[2]; match __v_145.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_148: G = __loaded[0]; let __v_149: G = __loaded[1]; let __v_150: G = __loaded[2]; match __v_148.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_151: G = __loaded[0]; let __v_152: G = __loaded[1]; let __v_153: G = __loaded[2]; match __v_151.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_154: G = __loaded[0]; let __v_155: G = __loaded[1]; let __v_156: G = __loaded[2]; match __v_154.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_157: G = __loaded[0]; let __v_158: G = __loaded[1]; let __v_159: G = __loaded[2]; match __v_157.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_160: G = __loaded[0]; let __v_161: G = __loaded[1]; let __v_162: G = __loaded[2]; match __v_160.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_163: G = __loaded[0]; let __v_164: G = __loaded[1]; let __v_165: G = __loaded[2]; match __v_163.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_166: G = __loaded[0]; let __v_167: G = __loaded[1]; let __v_168: G = __loaded[2]; match __v_166.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; match __v_169.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_172: G = __loaded[0]; let __v_173: G = __loaded[1]; let __v_174: G = __loaded[2]; match __v_172.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_175: G = __loaded[0]; let __v_176: G = __loaded[1]; let __v_177: G = __loaded[2]; match __v_175.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_178: G = __loaded[0]; let __v_179: G = __loaded[1]; let __v_180: G = __loaded[2]; match __v_178.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_181: G = __loaded[0]; let __v_182: G = __loaded[1]; let __v_183: G = __loaded[2]; match __v_181.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_184: G = __loaded[0]; let __v_185: G = __loaded[1]; let __v_186: G = __loaded[2]; match __v_184.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_187: G = __loaded[0]; let __v_188: G = __loaded[1]; let __v_189: G = __loaded[2]; match __v_187.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_190: G = __loaded[0]; let __v_191: G = __loaded[1]; let __v_192: G = __loaded[2]; match __v_190.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_69] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; - record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[69].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -4535,30 +4606,31 @@ const INPUT_SIZE_70: usize = 2; const IN_70: usize = 2; const OUT_70: usize = 1; fn aiur_fn_70( - inp: [G; IN_70], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_70], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(70); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_70] = [__v_0]; - record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[70].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); let __v_3: G = G::from_u64(0); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[70].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i)?; } record.function_queries[70].output_at(__i).to_array::() }, _ => aiur_fn_70(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_70] = [__v_7]; - record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[70].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -4569,18 +4641,19 @@ const INPUT_SIZE_71: usize = 6; const IN_71: usize = 6; const OUT_71: usize = 1; fn aiur_fn_71( - inp: [G; IN_71], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_71], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(71); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); @@ -4588,7 +4661,7 @@ fn aiur_fn_71( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4615,7 +4688,7 @@ fn aiur_fn_71( 0u64 => { let __v_17: G = (__v_6 + __v_7); let __v_18: G = (__v_8 + __v_17); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -4712,7 +4785,7 @@ fn aiur_fn_71( let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); let __v_114: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; @@ -4746,7 +4819,7 @@ fn aiur_fn_71( let __v_145: G = G::from_u64(0); let __v_146: G = G::from_u64(0); let __v_147: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_147, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_140, __v_141, __v_142, __v_18, __v_143, __v_144, __v_145, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -4779,70 +4852,70 @@ fn aiur_fn_71( let __v_177: G = __r_arr[29]; let __v_178: G = __r_arr[30]; let __v_179: G = __r_arr[31]; - let __v_180: G = { let __values: [G; 34] = [__v_146, __v_5, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_71] = [__v_180]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_71] = [__v_5]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -4875,15 +4948,15 @@ fn aiur_fn_71( let __v_39: G = __loaded[29]; let __v_40: G = __loaded[30]; let __v_41: G = __loaded[31]; - let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_71] = [__v_42]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -4892,7 +4965,7 @@ fn aiur_fn_71( let __v_14: G = __loaded[5]; let __v_15: G = __loaded[6]; let __v_16: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -4902,9 +4975,9 @@ fn aiur_fn_71( let __v_23: G = (__v_7 + __v_22); let __v_24: G = G::from_u64(64); let __v_25: G = (__v_24 - __v_1); - let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_0, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[70].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i)?; } record.function_queries[70].output_at(__i).to_array::() }, _ => aiur_fn_70(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, 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]; @@ -4969,7 +5042,7 @@ fn aiur_fn_71( let __v_88: G = __r_arr[61]; let __v_89: G = __r_arr[62]; let __v_90: G = __r_arr[63]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; @@ -5002,7 +5075,7 @@ fn aiur_fn_71( let __v_120: G = __loaded[29]; let __v_121: G = __loaded[30]; let __v_122: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_123: G = __loaded[0]; let __v_124: G = __loaded[1]; let __v_125: G = __loaded[2]; @@ -5035,7 +5108,7 @@ fn aiur_fn_71( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_1, __v_147, __v_148, __v_149, __v_23, __v_150, __v_151, __v_152, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -5068,9 +5141,9 @@ fn aiur_fn_71( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_71] = [__v_187]; - record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[71].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -5081,22 +5154,23 @@ const INPUT_SIZE_72: usize = 6; const IN_72: usize = 6; const OUT_72: usize = 1; fn aiur_fn_72( - inp: [G; IN_72], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_72], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(72); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(8); - let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[69].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i)?; } record.function_queries[69].output_at(__i).to_array::() }, _ => aiur_fn_69(__key, 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]; @@ -5163,9 +5237,9 @@ fn aiur_fn_72( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[251].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i)?; } record.function_queries[251].output_at(__i).to_array::() }, _ => aiur_fn_251(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_74: G = __loaded[0]; let __v_75: G = __loaded[1]; let __v_76: G = __loaded[2]; @@ -5174,7 +5248,7 @@ fn aiur_fn_72( let __v_79: G = __loaded[5]; let __v_80: G = __loaded[6]; let __v_81: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -5211,7 +5285,7 @@ fn aiur_fn_72( let __v_115: G = G::from_u64(205); let __v_116: G = G::from_u64(224); let __v_117: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; @@ -5244,7 +5318,7 @@ fn aiur_fn_72( let __v_147: G = __loaded[29]; let __v_148: G = __loaded[30]; let __v_149: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_150: G = __loaded[0]; let __v_151: G = __loaded[1]; let __v_152: G = __loaded[2]; @@ -5278,7 +5352,7 @@ fn aiur_fn_72( let __v_180: G = G::from_u64(0); let __v_181: G = G::from_u64(0); let __v_182: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_182, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_175, __v_176, __v_177, __v_85, __v_178, __v_179, __v_180, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -5311,13 +5385,13 @@ fn aiur_fn_72( let __v_212: G = __r_arr[29]; let __v_213: G = __r_arr[30]; let __v_214: G = __r_arr[31]; - let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 34] = [__v_181, __v_5, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_216: G = G::from_u64(1); let __v_217: G = G::from_u64(1); - let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_218: G = { let __values: [G; 3] = [__v_216, __v_217, __v_217]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_219: G = G::from_u64(0); let __v_220: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_221: G = __loaded[0]; let __v_222: G = __loaded[1]; let __v_223: G = __loaded[2]; @@ -5326,7 +5400,7 @@ fn aiur_fn_72( let __v_226: G = __loaded[5]; let __v_227: G = __loaded[6]; let __v_228: G = __loaded[7]; - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[12].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i)?; } record.function_queries[12].output_at(__i).to_array::() }, _ => aiur_fn_12(__key, 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]; @@ -5335,21 +5409,21 @@ fn aiur_fn_72( let __v_234: G = __r_arr[5]; let __v_235: G = __r_arr[6]; let __v_236: G = __r_arr[7]; - let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_238: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_237: G = { let __values: [G; 8] = [__v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_218, __v_219, __v_220, __v_237, __v_238, __v_215]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_239: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_239]; - record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[72].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[251].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i)?; } record.function_queries[251].output_at(__i).to_array::() }, _ => aiur_fn_251(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[251].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i)?; } record.function_queries[251].output_at(__i).to_array::() }, _ => aiur_fn_251(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; @@ -5358,7 +5432,7 @@ fn aiur_fn_72( let __v_81: G = __loaded[5]; let __v_82: G = __loaded[6]; let __v_83: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -5368,7 +5442,7 @@ fn aiur_fn_72( let __v_90: G = (__v_89 * __v_6); let __v_91: G = (__v_86 + __v_90); let __v_92: G = (__v_74 + __v_91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_93: G = __loaded[0]; let __v_94: G = __loaded[1]; let __v_95: G = __loaded[2]; @@ -5401,7 +5475,7 @@ fn aiur_fn_72( let __v_122: G = __loaded[29]; let __v_123: G = __loaded[30]; let __v_124: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_125: G = __loaded[0]; let __v_126: G = __loaded[1]; let __v_127: G = __loaded[2]; @@ -5434,7 +5508,7 @@ fn aiur_fn_72( let __v_154: G = G::from_u64(0); let __v_155: G = G::from_u64(0); let __v_156: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_156, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_150, __v_151, __v_152, __v_92, __v_153, __v_154, __v_155, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -5469,15 +5543,15 @@ fn aiur_fn_72( let __v_188: G = __r_arr[31]; let __v_189: G = G::from_u64(1); let __v_190: G = G::from_u64(1); - let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_189, __v_190, __v_190]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_192: G = G::from_u64(0); let __v_193: G = G::from_u64(1); let __v_194: G = (__v_2 + __v_193); - let __v_195: G = { let __values: [G; 32] = [__v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_191, __v_192, __v_194, __v_3, __v_195, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_196: G = __r_arr[0]; let __ret: [G; OUT_72] = [__v_196]; - record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[72].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -5488,36 +5562,37 @@ const INPUT_SIZE_73: usize = 24; const IN_73: usize = 24; const OUT_73: usize = 16; fn aiur_fn_73( - inp: [G; IN_73], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_73], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; + record.checkpoint(73); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_4.as_canonical_u64() << 0) | (__v_5.as_canonical_u64() << 8) | (__v_6.as_canonical_u64() << 16) | (__v_7.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_24: G = G::from_u8(__u32_bytes[0]); @@ -5525,8 +5600,8 @@ fn aiur_fn_73( let __v_26: G = G::from_u8(__u32_bytes[2]); let __v_27: G = G::from_u8(__u32_bytes[3]); let __v_28: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_29: G = G::from_u64(1); let __v_30: G = (__v_28 - __v_29); let __v_31: G = G::from_u64(2); @@ -5537,10 +5612,10 @@ fn aiur_fn_73( if (__v_34 != __v_35) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_35.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_36: G = if unconstrained { Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record) }; - let __v_37: G = if unconstrained { Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record) }; - let __v_38: G = if unconstrained { Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record) }; - let __v_39: G = if unconstrained { Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record) }; + let __v_36: G = if unconstrained { Bytes2::validate_inputs(&__v_12, &__v_24)?; Bytes2::xor(&__v_12, &__v_24) } else { bytes2_xor_value(__v_12, __v_24, record)? }; + let __v_37: G = if unconstrained { Bytes2::validate_inputs(&__v_13, &__v_25)?; Bytes2::xor(&__v_13, &__v_25) } else { bytes2_xor_value(__v_13, __v_25, record)? }; + let __v_38: G = if unconstrained { Bytes2::validate_inputs(&__v_14, &__v_26)?; Bytes2::xor(&__v_14, &__v_26) } else { bytes2_xor_value(__v_14, __v_26, record)? }; + let __v_39: G = if unconstrained { Bytes2::validate_inputs(&__v_15, &__v_27)?; Bytes2::xor(&__v_15, &__v_27) } else { bytes2_xor_value(__v_15, __v_27, record)? }; let __u32_sum: u128 = u128::from(((__v_8.as_canonical_u64() << 0) | (__v_9.as_canonical_u64() << 8) | (__v_10.as_canonical_u64() << 16) | (__v_11.as_canonical_u64() << 24))) + u128::from(((__v_38.as_canonical_u64() << 0) | (__v_39.as_canonical_u64() << 8) | (__v_36.as_canonical_u64() << 16) | (__v_37.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_40: G = G::from_u8(__u32_bytes[0]); @@ -5548,22 +5623,22 @@ fn aiur_fn_73( let __v_42: G = G::from_u8(__u32_bytes[2]); let __v_43: G = G::from_u8(__u32_bytes[3]); let __v_44: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_45: G = (__v_44 * __v_44); if (__v_45 != __v_44) { return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_40)?; Bytes2::xor_split4(&__v_4, &__v_40) } else { bytes2_xor_split4_value(__v_4, __v_40, record)? }; let __v_46: G = __b2_out.0; let __v_47: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_41)?; Bytes2::xor_split4(&__v_5, &__v_41) } else { bytes2_xor_split4_value(__v_5, __v_41, record)? }; let __v_48: G = __b2_out.0; let __v_49: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_42)?; Bytes2::xor_split4(&__v_6, &__v_42) } else { bytes2_xor_split4_value(__v_6, __v_42, record)? }; let __v_50: G = __b2_out.0; let __v_51: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_43)?; Bytes2::xor_split4(&__v_7, &__v_43) } else { bytes2_xor_split4_value(__v_7, __v_43, record)? }; let __v_52: G = __b2_out.0; let __v_53: G = __b2_out.1; let __v_54: G = (__v_48 + __v_51); @@ -5577,8 +5652,8 @@ fn aiur_fn_73( let __v_60: G = G::from_u8(__u32_bytes[2]); let __v_61: G = G::from_u8(__u32_bytes[3]); let __v_62: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_63: G = G::from_u64(1); let __v_64: G = (__v_62 - __v_63); let __v_65: G = G::from_u64(2); @@ -5589,10 +5664,10 @@ fn aiur_fn_73( if (__v_68 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_70: G = if unconstrained { Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record) }; - let __v_71: G = if unconstrained { Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record) }; - let __v_72: G = if unconstrained { Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record) }; - let __v_73: G = if unconstrained { Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record) }; + let __v_70: G = if unconstrained { Bytes2::validate_inputs(&__v_38, &__v_58)?; Bytes2::xor(&__v_38, &__v_58) } else { bytes2_xor_value(__v_38, __v_58, record)? }; + let __v_71: G = if unconstrained { Bytes2::validate_inputs(&__v_39, &__v_59)?; Bytes2::xor(&__v_39, &__v_59) } else { bytes2_xor_value(__v_39, __v_59, record)? }; + let __v_72: G = if unconstrained { Bytes2::validate_inputs(&__v_36, &__v_60)?; Bytes2::xor(&__v_36, &__v_60) } else { bytes2_xor_value(__v_36, __v_60, record)? }; + let __v_73: G = if unconstrained { Bytes2::validate_inputs(&__v_37, &__v_61)?; Bytes2::xor(&__v_37, &__v_61) } else { bytes2_xor_value(__v_37, __v_61, record)? }; let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_71.as_canonical_u64() << 0) | (__v_72.as_canonical_u64() << 8) | (__v_73.as_canonical_u64() << 16) | (__v_70.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_74: G = G::from_u8(__u32_bytes[0]); @@ -5600,22 +5675,22 @@ fn aiur_fn_73( let __v_76: G = G::from_u8(__u32_bytes[2]); let __v_77: G = G::from_u8(__u32_bytes[3]); let __v_78: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_74; let __vj = __v_75; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_74; let __vj = __v_75; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_76; let __vj = __v_77; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_79: G = (__v_78 * __v_78); if (__v_79 != __v_78) { return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_78.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_74)?; Bytes2::xor_split7(&__v_54, &__v_74) } else { bytes2_xor_split7_value(__v_54, __v_74, record)? }; let __v_80: G = __b2_out.0; let __v_81: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_75)?; Bytes2::xor_split7(&__v_55, &__v_75) } else { bytes2_xor_split7_value(__v_55, __v_75, record)? }; let __v_82: G = __b2_out.0; let __v_83: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_76)?; Bytes2::xor_split7(&__v_56, &__v_76) } else { bytes2_xor_split7_value(__v_56, __v_76, record)? }; let __v_84: G = __b2_out.0; let __v_85: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_77)?; Bytes2::xor_split7(&__v_57, &__v_77) } else { bytes2_xor_split7_value(__v_57, __v_77, record)? }; let __v_86: G = __b2_out.0; let __v_87: G = __b2_out.1; let __v_88: G = (__v_80 + __v_83); @@ -5623,7 +5698,7 @@ fn aiur_fn_73( let __v_90: G = (__v_84 + __v_87); let __v_91: G = (__v_86 + __v_81); let __ret: [G; OUT_73] = [__v_58, __v_59, __v_60, __v_61, __v_88, __v_89, __v_90, __v_91, __v_74, __v_75, __v_76, __v_77, __v_71, __v_72, __v_73, __v_70]; - record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[73].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -5632,140 +5707,141 @@ const INPUT_SIZE_74: usize = 128; const IN_74: usize = 128; const OUT_74: usize = 128; fn aiur_fn_74( - inp: [G; IN_74], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_74], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; - let __v_106: G = inp[106]; - let __v_107: G = inp[107]; - let __v_108: G = inp[108]; - let __v_109: G = inp[109]; - let __v_110: G = inp[110]; - let __v_111: G = inp[111]; - let __v_112: G = inp[112]; - let __v_113: G = inp[113]; - let __v_114: G = inp[114]; - let __v_115: G = inp[115]; - let __v_116: G = inp[116]; - let __v_117: G = inp[117]; - let __v_118: G = inp[118]; - let __v_119: G = inp[119]; - let __v_120: G = inp[120]; - let __v_121: G = inp[121]; - let __v_122: G = inp[122]; - let __v_123: G = inp[123]; - let __v_124: G = inp[124]; - let __v_125: G = inp[125]; - let __v_126: G = inp[126]; - let __v_127: G = inp[127]; + record.checkpoint(74); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; + let __v_106: G = inp.values()[106]; + let __v_107: G = inp.values()[107]; + let __v_108: G = inp.values()[108]; + let __v_109: G = inp.values()[109]; + let __v_110: G = inp.values()[110]; + let __v_111: G = inp.values()[111]; + let __v_112: G = inp.values()[112]; + let __v_113: G = inp.values()[113]; + let __v_114: G = inp.values()[114]; + let __v_115: G = inp.values()[115]; + let __v_116: G = inp.values()[116]; + let __v_117: G = inp.values()[117]; + let __v_118: G = inp.values()[118]; + let __v_119: G = inp.values()[119]; + let __v_120: G = inp.values()[120]; + let __v_121: G = inp.values()[121]; + let __v_122: G = inp.values()[122]; + let __v_123: G = inp.values()[123]; + let __v_124: G = inp.values()[124]; + let __v_125: G = inp.values()[125]; + let __v_126: G = inp.values()[126]; + let __v_127: G = inp.values()[127]; let __u32_sum: u128 = u128::from(((__v_0.as_canonical_u64() << 0) | (__v_1.as_canonical_u64() << 8) | (__v_2.as_canonical_u64() << 16) | (__v_3.as_canonical_u64() << 24))) + u128::from(((__v_16.as_canonical_u64() << 0) | (__v_17.as_canonical_u64() << 8) | (__v_18.as_canonical_u64() << 16) | (__v_19.as_canonical_u64() << 24))) + u128::from(((__v_64.as_canonical_u64() << 0) | (__v_65.as_canonical_u64() << 8) | (__v_66.as_canonical_u64() << 16) | (__v_67.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_128: G = G::from_u8(__u32_bytes[0]); @@ -5773,8 +5849,8 @@ fn aiur_fn_74( let __v_130: G = G::from_u8(__u32_bytes[2]); let __v_131: G = G::from_u8(__u32_bytes[3]); let __v_132: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_128; let __vj = __v_129; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_130; let __vj = __v_131; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_128; let __vj = __v_129; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_130; let __vj = __v_131; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_133: G = G::from_u64(1); let __v_134: G = (__v_132 - __v_133); let __v_135: G = G::from_u64(2); @@ -5785,10 +5861,10 @@ fn aiur_fn_74( if (__v_138 != __v_139) { return Err(ExecError::AssertEqMismatch { lhs: __v_138.as_canonical_u64(), rhs: __v_139.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_140: G = if unconstrained { Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record) }; - let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) }; + let __v_140: G = if unconstrained { Bytes2::validate_inputs(&__v_48, &__v_128)?; Bytes2::xor(&__v_48, &__v_128) } else { bytes2_xor_value(__v_48, __v_128, record)? }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_49, &__v_129)?; Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_50, &__v_130)?; Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_51, &__v_131)?; Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record)? }; let __u32_sum: u128 = u128::from(((__v_32.as_canonical_u64() << 0) | (__v_33.as_canonical_u64() << 8) | (__v_34.as_canonical_u64() << 16) | (__v_35.as_canonical_u64() << 24))) + u128::from(((__v_142.as_canonical_u64() << 0) | (__v_143.as_canonical_u64() << 8) | (__v_140.as_canonical_u64() << 16) | (__v_141.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_144: G = G::from_u8(__u32_bytes[0]); @@ -5796,22 +5872,22 @@ fn aiur_fn_74( let __v_146: G = G::from_u8(__u32_bytes[2]); let __v_147: G = G::from_u8(__u32_bytes[3]); let __v_148: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_144; let __vj = __v_145; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_146; let __vj = __v_147; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_144; let __vj = __v_145; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_146; let __vj = __v_147; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_149: G = (__v_148 * __v_148); if (__v_149 != __v_148) { return Err(ExecError::AssertEqMismatch { lhs: __v_149.as_canonical_u64(), rhs: __v_148.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_144)?; Bytes2::xor_split4(&__v_16, &__v_144) } else { bytes2_xor_split4_value(__v_16, __v_144, record)? }; let __v_150: G = __b2_out.0; let __v_151: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_145)?; Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record)? }; let __v_152: G = __b2_out.0; let __v_153: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_146)?; Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record)? }; let __v_154: G = __b2_out.0; let __v_155: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_147)?; Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record)? }; let __v_156: G = __b2_out.0; let __v_157: G = __b2_out.1; let __v_158: G = (__v_152 + __v_155); @@ -5825,8 +5901,8 @@ fn aiur_fn_74( let __v_164: G = G::from_u8(__u32_bytes[2]); let __v_165: G = G::from_u8(__u32_bytes[3]); let __v_166: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_162; let __vj = __v_163; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_164; let __vj = __v_165; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_162; let __vj = __v_163; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_164; let __vj = __v_165; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_167: G = G::from_u64(1); let __v_168: G = (__v_166 - __v_167); let __v_169: G = G::from_u64(2); @@ -5837,10 +5913,10 @@ fn aiur_fn_74( if (__v_172 != __v_173) { return Err(ExecError::AssertEqMismatch { lhs: __v_172.as_canonical_u64(), rhs: __v_173.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_174: G = if unconstrained { Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record) }; - let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) }; - let __v_176: G = if unconstrained { Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record) }; - let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) }; + let __v_174: G = if unconstrained { Bytes2::validate_inputs(&__v_142, &__v_162)?; Bytes2::xor(&__v_142, &__v_162) } else { bytes2_xor_value(__v_142, __v_162, record)? }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_143, &__v_163)?; Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record)? }; + let __v_176: G = if unconstrained { Bytes2::validate_inputs(&__v_140, &__v_164)?; Bytes2::xor(&__v_140, &__v_164) } else { bytes2_xor_value(__v_140, __v_164, record)? }; + let __v_177: G = if unconstrained { Bytes2::validate_inputs(&__v_141, &__v_165)?; Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record)? }; let __u32_sum: u128 = u128::from(((__v_144.as_canonical_u64() << 0) | (__v_145.as_canonical_u64() << 8) | (__v_146.as_canonical_u64() << 16) | (__v_147.as_canonical_u64() << 24))) + u128::from(((__v_175.as_canonical_u64() << 0) | (__v_176.as_canonical_u64() << 8) | (__v_177.as_canonical_u64() << 16) | (__v_174.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_178: G = G::from_u8(__u32_bytes[0]); @@ -5848,22 +5924,22 @@ fn aiur_fn_74( let __v_180: G = G::from_u8(__u32_bytes[2]); let __v_181: G = G::from_u8(__u32_bytes[3]); let __v_182: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_178; let __vj = __v_179; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_180; let __vj = __v_181; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_178; let __vj = __v_179; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_180; let __vj = __v_181; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_183: G = (__v_182 * __v_182); if (__v_183 != __v_182) { return Err(ExecError::AssertEqMismatch { lhs: __v_183.as_canonical_u64(), rhs: __v_182.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_158, &__v_178)?; Bytes2::xor_split7(&__v_158, &__v_178) } else { bytes2_xor_split7_value(__v_158, __v_178, record)? }; let __v_184: G = __b2_out.0; let __v_185: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_159, &__v_179)?; Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record)? }; let __v_186: G = __b2_out.0; let __v_187: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_160, &__v_180)?; Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record)? }; let __v_188: G = __b2_out.0; let __v_189: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_161, &__v_181)?; Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record)? }; let __v_190: G = __b2_out.0; let __v_191: G = __b2_out.1; let __v_192: G = (__v_184 + __v_187); @@ -5877,8 +5953,8 @@ fn aiur_fn_74( let __v_198: G = G::from_u8(__u32_bytes[2]); let __v_199: G = G::from_u8(__u32_bytes[3]); let __v_200: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_196; let __vj = __v_197; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_198; let __vj = __v_199; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_196; let __vj = __v_197; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_198; let __vj = __v_199; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_201: G = G::from_u64(1); let __v_202: G = (__v_200 - __v_201); let __v_203: G = G::from_u64(2); @@ -5889,10 +5965,10 @@ fn aiur_fn_74( if (__v_206 != __v_207) { return Err(ExecError::AssertEqMismatch { lhs: __v_206.as_canonical_u64(), rhs: __v_207.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_208: G = if unconstrained { Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record) }; - let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) }; - let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) }; - let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) }; + let __v_208: G = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_196)?; Bytes2::xor(&__v_52, &__v_196) } else { bytes2_xor_value(__v_52, __v_196, record)? }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_53, &__v_197)?; Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record)? }; + let __v_210: G = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_198)?; Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record)? }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_199)?; Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record)? }; let __u32_sum: u128 = u128::from(((__v_36.as_canonical_u64() << 0) | (__v_37.as_canonical_u64() << 8) | (__v_38.as_canonical_u64() << 16) | (__v_39.as_canonical_u64() << 24))) + u128::from(((__v_210.as_canonical_u64() << 0) | (__v_211.as_canonical_u64() << 8) | (__v_208.as_canonical_u64() << 16) | (__v_209.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_212: G = G::from_u8(__u32_bytes[0]); @@ -5900,22 +5976,22 @@ fn aiur_fn_74( let __v_214: G = G::from_u8(__u32_bytes[2]); let __v_215: G = G::from_u8(__u32_bytes[3]); let __v_216: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_212; let __vj = __v_213; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_214; let __vj = __v_215; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_212; let __vj = __v_213; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_214; let __vj = __v_215; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_217: G = (__v_216 * __v_216); if (__v_217 != __v_216) { return Err(ExecError::AssertEqMismatch { lhs: __v_217.as_canonical_u64(), rhs: __v_216.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_212)?; Bytes2::xor_split4(&__v_20, &__v_212) } else { bytes2_xor_split4_value(__v_20, __v_212, record)? }; let __v_218: G = __b2_out.0; let __v_219: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_213)?; Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record)? }; let __v_220: G = __b2_out.0; let __v_221: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_214)?; Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record)? }; let __v_222: G = __b2_out.0; let __v_223: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_215)?; Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record)? }; let __v_224: G = __b2_out.0; let __v_225: G = __b2_out.1; let __v_226: G = (__v_220 + __v_223); @@ -5929,8 +6005,8 @@ fn aiur_fn_74( let __v_232: G = G::from_u8(__u32_bytes[2]); let __v_233: G = G::from_u8(__u32_bytes[3]); let __v_234: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_230; let __vj = __v_231; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_232; let __vj = __v_233; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_230; let __vj = __v_231; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_232; let __vj = __v_233; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_235: G = G::from_u64(1); let __v_236: G = (__v_234 - __v_235); let __v_237: G = G::from_u64(2); @@ -5941,10 +6017,10 @@ fn aiur_fn_74( if (__v_240 != __v_241) { return Err(ExecError::AssertEqMismatch { lhs: __v_240.as_canonical_u64(), rhs: __v_241.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_242: G = if unconstrained { Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record) }; - let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) }; - let __v_244: G = if unconstrained { Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record) }; - let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) }; + let __v_242: G = if unconstrained { Bytes2::validate_inputs(&__v_210, &__v_230)?; Bytes2::xor(&__v_210, &__v_230) } else { bytes2_xor_value(__v_210, __v_230, record)? }; + let __v_243: G = if unconstrained { Bytes2::validate_inputs(&__v_211, &__v_231)?; Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record)? }; + let __v_244: G = if unconstrained { Bytes2::validate_inputs(&__v_208, &__v_232)?; Bytes2::xor(&__v_208, &__v_232) } else { bytes2_xor_value(__v_208, __v_232, record)? }; + let __v_245: G = if unconstrained { Bytes2::validate_inputs(&__v_209, &__v_233)?; Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record)? }; let __u32_sum: u128 = u128::from(((__v_212.as_canonical_u64() << 0) | (__v_213.as_canonical_u64() << 8) | (__v_214.as_canonical_u64() << 16) | (__v_215.as_canonical_u64() << 24))) + u128::from(((__v_243.as_canonical_u64() << 0) | (__v_244.as_canonical_u64() << 8) | (__v_245.as_canonical_u64() << 16) | (__v_242.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_246: G = G::from_u8(__u32_bytes[0]); @@ -5952,22 +6028,22 @@ fn aiur_fn_74( let __v_248: G = G::from_u8(__u32_bytes[2]); let __v_249: G = G::from_u8(__u32_bytes[3]); let __v_250: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_246; let __vj = __v_247; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_248; let __vj = __v_249; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_246; let __vj = __v_247; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_248; let __vj = __v_249; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_251: G = (__v_250 * __v_250); if (__v_251 != __v_250) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_250.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_226, &__v_246)?; Bytes2::xor_split7(&__v_226, &__v_246) } else { bytes2_xor_split7_value(__v_226, __v_246, record)? }; let __v_252: G = __b2_out.0; let __v_253: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_227, &__v_247)?; Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record)? }; let __v_254: G = __b2_out.0; let __v_255: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_228, &__v_248)?; Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record)? }; let __v_256: G = __b2_out.0; let __v_257: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_229, &__v_249)?; Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record)? }; let __v_258: G = __b2_out.0; let __v_259: G = __b2_out.1; let __v_260: G = (__v_252 + __v_255); @@ -5981,8 +6057,8 @@ fn aiur_fn_74( let __v_266: G = G::from_u8(__u32_bytes[2]); let __v_267: G = G::from_u8(__u32_bytes[3]); let __v_268: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_264; let __vj = __v_265; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_266; let __vj = __v_267; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_264; let __vj = __v_265; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_266; let __vj = __v_267; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_269: G = G::from_u64(1); let __v_270: G = (__v_268 - __v_269); let __v_271: G = G::from_u64(2); @@ -5993,10 +6069,10 @@ fn aiur_fn_74( if (__v_274 != __v_275) { return Err(ExecError::AssertEqMismatch { lhs: __v_274.as_canonical_u64(), rhs: __v_275.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_276: G = if unconstrained { Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record) }; - let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) }; - let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) }; - let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) }; + let __v_276: G = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_264)?; Bytes2::xor(&__v_56, &__v_264) } else { bytes2_xor_value(__v_56, __v_264, record)? }; + let __v_277: G = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_265)?; Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record)? }; + let __v_278: G = if unconstrained { Bytes2::validate_inputs(&__v_58, &__v_266)?; Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record)? }; + let __v_279: G = if unconstrained { Bytes2::validate_inputs(&__v_59, &__v_267)?; Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record)? }; let __u32_sum: u128 = u128::from(((__v_40.as_canonical_u64() << 0) | (__v_41.as_canonical_u64() << 8) | (__v_42.as_canonical_u64() << 16) | (__v_43.as_canonical_u64() << 24))) + u128::from(((__v_278.as_canonical_u64() << 0) | (__v_279.as_canonical_u64() << 8) | (__v_276.as_canonical_u64() << 16) | (__v_277.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_280: G = G::from_u8(__u32_bytes[0]); @@ -6004,22 +6080,22 @@ fn aiur_fn_74( let __v_282: G = G::from_u8(__u32_bytes[2]); let __v_283: G = G::from_u8(__u32_bytes[3]); let __v_284: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_280; let __vj = __v_281; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_282; let __vj = __v_283; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_280; let __vj = __v_281; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_282; let __vj = __v_283; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_285: G = (__v_284 * __v_284); if (__v_285 != __v_284) { return Err(ExecError::AssertEqMismatch { lhs: __v_285.as_canonical_u64(), rhs: __v_284.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_280)?; Bytes2::xor_split4(&__v_24, &__v_280) } else { bytes2_xor_split4_value(__v_24, __v_280, record)? }; let __v_286: G = __b2_out.0; let __v_287: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_281)?; Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record)? }; let __v_288: G = __b2_out.0; let __v_289: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_282)?; Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record)? }; let __v_290: G = __b2_out.0; let __v_291: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_283)?; Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record)? }; let __v_292: G = __b2_out.0; let __v_293: G = __b2_out.1; let __v_294: G = (__v_288 + __v_291); @@ -6033,8 +6109,8 @@ fn aiur_fn_74( let __v_300: G = G::from_u8(__u32_bytes[2]); let __v_301: G = G::from_u8(__u32_bytes[3]); let __v_302: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_298; let __vj = __v_299; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_300; let __vj = __v_301; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_298; let __vj = __v_299; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_300; let __vj = __v_301; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_303: G = G::from_u64(1); let __v_304: G = (__v_302 - __v_303); let __v_305: G = G::from_u64(2); @@ -6045,10 +6121,10 @@ fn aiur_fn_74( if (__v_308 != __v_309) { return Err(ExecError::AssertEqMismatch { lhs: __v_308.as_canonical_u64(), rhs: __v_309.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_310: G = if unconstrained { Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record) }; - let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) }; - let __v_312: G = if unconstrained { Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record) }; - let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) }; + let __v_310: G = if unconstrained { Bytes2::validate_inputs(&__v_278, &__v_298)?; Bytes2::xor(&__v_278, &__v_298) } else { bytes2_xor_value(__v_278, __v_298, record)? }; + let __v_311: G = if unconstrained { Bytes2::validate_inputs(&__v_279, &__v_299)?; Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record)? }; + let __v_312: G = if unconstrained { Bytes2::validate_inputs(&__v_276, &__v_300)?; Bytes2::xor(&__v_276, &__v_300) } else { bytes2_xor_value(__v_276, __v_300, record)? }; + let __v_313: G = if unconstrained { Bytes2::validate_inputs(&__v_277, &__v_301)?; Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record)? }; let __u32_sum: u128 = u128::from(((__v_280.as_canonical_u64() << 0) | (__v_281.as_canonical_u64() << 8) | (__v_282.as_canonical_u64() << 16) | (__v_283.as_canonical_u64() << 24))) + u128::from(((__v_311.as_canonical_u64() << 0) | (__v_312.as_canonical_u64() << 8) | (__v_313.as_canonical_u64() << 16) | (__v_310.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_314: G = G::from_u8(__u32_bytes[0]); @@ -6056,22 +6132,22 @@ fn aiur_fn_74( let __v_316: G = G::from_u8(__u32_bytes[2]); let __v_317: G = G::from_u8(__u32_bytes[3]); let __v_318: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_314; let __vj = __v_315; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_316; let __vj = __v_317; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_314; let __vj = __v_315; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_316; let __vj = __v_317; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_319: G = (__v_318 * __v_318); if (__v_319 != __v_318) { return Err(ExecError::AssertEqMismatch { lhs: __v_319.as_canonical_u64(), rhs: __v_318.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_294, &__v_314)?; Bytes2::xor_split7(&__v_294, &__v_314) } else { bytes2_xor_split7_value(__v_294, __v_314, record)? }; let __v_320: G = __b2_out.0; let __v_321: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_295, &__v_315)?; Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record)? }; let __v_322: G = __b2_out.0; let __v_323: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_296, &__v_316)?; Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record)? }; let __v_324: G = __b2_out.0; let __v_325: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_297, &__v_317)?; Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record)? }; let __v_326: G = __b2_out.0; let __v_327: G = __b2_out.1; let __v_328: G = (__v_320 + __v_323); @@ -6085,8 +6161,8 @@ fn aiur_fn_74( let __v_334: G = G::from_u8(__u32_bytes[2]); let __v_335: G = G::from_u8(__u32_bytes[3]); let __v_336: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_332; let __vj = __v_333; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_334; let __vj = __v_335; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_332; let __vj = __v_333; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_334; let __vj = __v_335; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_337: G = G::from_u64(1); let __v_338: G = (__v_336 - __v_337); let __v_339: G = G::from_u64(2); @@ -6097,10 +6173,10 @@ fn aiur_fn_74( if (__v_342 != __v_343) { return Err(ExecError::AssertEqMismatch { lhs: __v_342.as_canonical_u64(), rhs: __v_343.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_344: G = if unconstrained { Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record) }; - let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) }; - let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) }; - let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) }; + let __v_344: G = if unconstrained { Bytes2::validate_inputs(&__v_60, &__v_332)?; Bytes2::xor(&__v_60, &__v_332) } else { bytes2_xor_value(__v_60, __v_332, record)? }; + let __v_345: G = if unconstrained { Bytes2::validate_inputs(&__v_61, &__v_333)?; Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record)? }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_62, &__v_334)?; Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record)? }; + let __v_347: G = if unconstrained { Bytes2::validate_inputs(&__v_63, &__v_335)?; Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record)? }; let __u32_sum: u128 = u128::from(((__v_44.as_canonical_u64() << 0) | (__v_45.as_canonical_u64() << 8) | (__v_46.as_canonical_u64() << 16) | (__v_47.as_canonical_u64() << 24))) + u128::from(((__v_346.as_canonical_u64() << 0) | (__v_347.as_canonical_u64() << 8) | (__v_344.as_canonical_u64() << 16) | (__v_345.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_348: G = G::from_u8(__u32_bytes[0]); @@ -6108,22 +6184,22 @@ fn aiur_fn_74( let __v_350: G = G::from_u8(__u32_bytes[2]); let __v_351: G = G::from_u8(__u32_bytes[3]); let __v_352: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_348; let __vj = __v_349; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_350; let __vj = __v_351; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_348; let __vj = __v_349; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_350; let __vj = __v_351; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_353: G = (__v_352 * __v_352); if (__v_353 != __v_352) { return Err(ExecError::AssertEqMismatch { lhs: __v_353.as_canonical_u64(), rhs: __v_352.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_348)?; Bytes2::xor_split4(&__v_28, &__v_348) } else { bytes2_xor_split4_value(__v_28, __v_348, record)? }; let __v_354: G = __b2_out.0; let __v_355: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_349)?; Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record)? }; let __v_356: G = __b2_out.0; let __v_357: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_350)?; Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record)? }; let __v_358: G = __b2_out.0; let __v_359: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_351)?; Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record)? }; let __v_360: G = __b2_out.0; let __v_361: G = __b2_out.1; let __v_362: G = (__v_356 + __v_359); @@ -6137,8 +6213,8 @@ fn aiur_fn_74( let __v_368: G = G::from_u8(__u32_bytes[2]); let __v_369: G = G::from_u8(__u32_bytes[3]); let __v_370: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_366; let __vj = __v_367; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_368; let __vj = __v_369; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_366; let __vj = __v_367; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_368; let __vj = __v_369; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_371: G = G::from_u64(1); let __v_372: G = (__v_370 - __v_371); let __v_373: G = G::from_u64(2); @@ -6149,10 +6225,10 @@ fn aiur_fn_74( if (__v_376 != __v_377) { return Err(ExecError::AssertEqMismatch { lhs: __v_376.as_canonical_u64(), rhs: __v_377.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_378: G = if unconstrained { Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record) }; - let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) }; - let __v_380: G = if unconstrained { Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record) }; - let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) }; + let __v_378: G = if unconstrained { Bytes2::validate_inputs(&__v_346, &__v_366)?; Bytes2::xor(&__v_346, &__v_366) } else { bytes2_xor_value(__v_346, __v_366, record)? }; + let __v_379: G = if unconstrained { Bytes2::validate_inputs(&__v_347, &__v_367)?; Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record)? }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_344, &__v_368)?; Bytes2::xor(&__v_344, &__v_368) } else { bytes2_xor_value(__v_344, __v_368, record)? }; + let __v_381: G = if unconstrained { Bytes2::validate_inputs(&__v_345, &__v_369)?; Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record)? }; let __u32_sum: u128 = u128::from(((__v_348.as_canonical_u64() << 0) | (__v_349.as_canonical_u64() << 8) | (__v_350.as_canonical_u64() << 16) | (__v_351.as_canonical_u64() << 24))) + u128::from(((__v_379.as_canonical_u64() << 0) | (__v_380.as_canonical_u64() << 8) | (__v_381.as_canonical_u64() << 16) | (__v_378.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_382: G = G::from_u8(__u32_bytes[0]); @@ -6160,22 +6236,22 @@ fn aiur_fn_74( let __v_384: G = G::from_u8(__u32_bytes[2]); let __v_385: G = G::from_u8(__u32_bytes[3]); let __v_386: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_382; let __vj = __v_383; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_384; let __vj = __v_385; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_382; let __vj = __v_383; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_384; let __vj = __v_385; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_387: G = (__v_386 * __v_386); if (__v_387 != __v_386) { return Err(ExecError::AssertEqMismatch { lhs: __v_387.as_canonical_u64(), rhs: __v_386.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_362, &__v_382)?; Bytes2::xor_split7(&__v_362, &__v_382) } else { bytes2_xor_split7_value(__v_362, __v_382, record)? }; let __v_388: G = __b2_out.0; let __v_389: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_363, &__v_383)?; Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record)? }; let __v_390: G = __b2_out.0; let __v_391: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_364, &__v_384)?; Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record)? }; let __v_392: G = __b2_out.0; let __v_393: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_365, &__v_385)?; Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record)? }; let __v_394: G = __b2_out.0; let __v_395: G = __b2_out.1; let __v_396: G = (__v_388 + __v_391); @@ -6189,8 +6265,8 @@ fn aiur_fn_74( let __v_402: G = G::from_u8(__u32_bytes[2]); let __v_403: G = G::from_u8(__u32_bytes[3]); let __v_404: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_400; let __vj = __v_401; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_402; let __vj = __v_403; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_400; let __vj = __v_401; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_402; let __vj = __v_403; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_405: G = G::from_u64(1); let __v_406: G = (__v_404 - __v_405); let __v_407: G = G::from_u64(2); @@ -6201,10 +6277,10 @@ fn aiur_fn_74( if (__v_410 != __v_411) { return Err(ExecError::AssertEqMismatch { lhs: __v_410.as_canonical_u64(), rhs: __v_411.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_412: G = if unconstrained { Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record) }; - let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) }; - let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) }; - let __v_415: G = if unconstrained { Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record) }; + let __v_412: G = if unconstrained { Bytes2::validate_inputs(&__v_379, &__v_400)?; Bytes2::xor(&__v_379, &__v_400) } else { bytes2_xor_value(__v_379, __v_400, record)? }; + let __v_413: G = if unconstrained { Bytes2::validate_inputs(&__v_380, &__v_401)?; Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record)? }; + let __v_414: G = if unconstrained { Bytes2::validate_inputs(&__v_381, &__v_402)?; Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record)? }; + let __v_415: G = if unconstrained { Bytes2::validate_inputs(&__v_378, &__v_403)?; Bytes2::xor(&__v_378, &__v_403) } else { bytes2_xor_value(__v_378, __v_403, record)? }; let __u32_sum: u128 = u128::from(((__v_314.as_canonical_u64() << 0) | (__v_315.as_canonical_u64() << 8) | (__v_316.as_canonical_u64() << 16) | (__v_317.as_canonical_u64() << 24))) + u128::from(((__v_414.as_canonical_u64() << 0) | (__v_415.as_canonical_u64() << 8) | (__v_412.as_canonical_u64() << 16) | (__v_413.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_416: G = G::from_u8(__u32_bytes[0]); @@ -6212,22 +6288,22 @@ fn aiur_fn_74( let __v_418: G = G::from_u8(__u32_bytes[2]); let __v_419: G = G::from_u8(__u32_bytes[3]); let __v_420: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_416; let __vj = __v_417; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_418; let __vj = __v_419; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_416; let __vj = __v_417; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_418; let __vj = __v_419; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_421: G = (__v_420 * __v_420); if (__v_421 != __v_420) { return Err(ExecError::AssertEqMismatch { lhs: __v_421.as_canonical_u64(), rhs: __v_420.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_260, &__v_416)?; Bytes2::xor_split4(&__v_260, &__v_416) } else { bytes2_xor_split4_value(__v_260, __v_416, record)? }; let __v_422: G = __b2_out.0; let __v_423: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_261, &__v_417)?; Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record)? }; let __v_424: G = __b2_out.0; let __v_425: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_418)?; Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record)? }; let __v_426: G = __b2_out.0; let __v_427: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_419)?; Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record)? }; let __v_428: G = __b2_out.0; let __v_429: G = __b2_out.1; let __v_430: G = (__v_424 + __v_427); @@ -6241,8 +6317,8 @@ fn aiur_fn_74( let __v_436: G = G::from_u8(__u32_bytes[2]); let __v_437: G = G::from_u8(__u32_bytes[3]); let __v_438: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_434; let __vj = __v_435; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_436; let __vj = __v_437; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_434; let __vj = __v_435; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_436; let __vj = __v_437; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_439: G = G::from_u64(1); let __v_440: G = (__v_438 - __v_439); let __v_441: G = G::from_u64(2); @@ -6253,10 +6329,10 @@ fn aiur_fn_74( if (__v_444 != __v_445) { return Err(ExecError::AssertEqMismatch { lhs: __v_444.as_canonical_u64(), rhs: __v_445.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_446: G = if unconstrained { Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record) }; - let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) }; - let __v_448: G = if unconstrained { Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record) }; - let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) }; + let __v_446: G = if unconstrained { Bytes2::validate_inputs(&__v_414, &__v_434)?; Bytes2::xor(&__v_414, &__v_434) } else { bytes2_xor_value(__v_414, __v_434, record)? }; + let __v_447: G = if unconstrained { Bytes2::validate_inputs(&__v_415, &__v_435)?; Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record)? }; + let __v_448: G = if unconstrained { Bytes2::validate_inputs(&__v_412, &__v_436)?; Bytes2::xor(&__v_412, &__v_436) } else { bytes2_xor_value(__v_412, __v_436, record)? }; + let __v_449: G = if unconstrained { Bytes2::validate_inputs(&__v_413, &__v_437)?; Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record)? }; let __u32_sum: u128 = u128::from(((__v_416.as_canonical_u64() << 0) | (__v_417.as_canonical_u64() << 8) | (__v_418.as_canonical_u64() << 16) | (__v_419.as_canonical_u64() << 24))) + u128::from(((__v_447.as_canonical_u64() << 0) | (__v_448.as_canonical_u64() << 8) | (__v_449.as_canonical_u64() << 16) | (__v_446.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_450: G = G::from_u8(__u32_bytes[0]); @@ -6264,22 +6340,22 @@ fn aiur_fn_74( let __v_452: G = G::from_u8(__u32_bytes[2]); let __v_453: G = G::from_u8(__u32_bytes[3]); let __v_454: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_450; let __vj = __v_451; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_452; let __vj = __v_453; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_450; let __vj = __v_451; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_452; let __vj = __v_453; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_455: G = (__v_454 * __v_454); if (__v_455 != __v_454) { return Err(ExecError::AssertEqMismatch { lhs: __v_455.as_canonical_u64(), rhs: __v_454.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_430, &__v_450)?; Bytes2::xor_split7(&__v_430, &__v_450) } else { bytes2_xor_split7_value(__v_430, __v_450, record)? }; let __v_456: G = __b2_out.0; let __v_457: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_431, &__v_451)?; Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record)? }; let __v_458: G = __b2_out.0; let __v_459: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_432, &__v_452)?; Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record)? }; let __v_460: G = __b2_out.0; let __v_461: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_433, &__v_453)?; Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record)? }; let __v_462: G = __b2_out.0; let __v_463: G = __b2_out.1; let __v_464: G = (__v_456 + __v_459); @@ -6293,8 +6369,8 @@ fn aiur_fn_74( let __v_470: G = G::from_u8(__u32_bytes[2]); let __v_471: G = G::from_u8(__u32_bytes[3]); let __v_472: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_468; let __vj = __v_469; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_470; let __vj = __v_471; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_468; let __vj = __v_469; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_470; let __vj = __v_471; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_473: G = G::from_u64(1); let __v_474: G = (__v_472 - __v_473); let __v_475: G = G::from_u64(2); @@ -6305,10 +6381,10 @@ fn aiur_fn_74( if (__v_478 != __v_479) { return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_480: G = if unconstrained { Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record) }; - let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) }; - let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) }; - let __v_483: G = if unconstrained { Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record) }; + let __v_480: G = if unconstrained { Bytes2::validate_inputs(&__v_175, &__v_468)?; Bytes2::xor(&__v_175, &__v_468) } else { bytes2_xor_value(__v_175, __v_468, record)? }; + let __v_481: G = if unconstrained { Bytes2::validate_inputs(&__v_176, &__v_469)?; Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record)? }; + let __v_482: G = if unconstrained { Bytes2::validate_inputs(&__v_177, &__v_470)?; Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record)? }; + let __v_483: G = if unconstrained { Bytes2::validate_inputs(&__v_174, &__v_471)?; Bytes2::xor(&__v_174, &__v_471) } else { bytes2_xor_value(__v_174, __v_471, record)? }; let __u32_sum: u128 = u128::from(((__v_382.as_canonical_u64() << 0) | (__v_383.as_canonical_u64() << 8) | (__v_384.as_canonical_u64() << 16) | (__v_385.as_canonical_u64() << 24))) + u128::from(((__v_482.as_canonical_u64() << 0) | (__v_483.as_canonical_u64() << 8) | (__v_480.as_canonical_u64() << 16) | (__v_481.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_484: G = G::from_u8(__u32_bytes[0]); @@ -6316,22 +6392,22 @@ fn aiur_fn_74( let __v_486: G = G::from_u8(__u32_bytes[2]); let __v_487: G = G::from_u8(__u32_bytes[3]); let __v_488: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_484; let __vj = __v_485; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_486; let __vj = __v_487; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_484; let __vj = __v_485; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_486; let __vj = __v_487; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_489: G = (__v_488 * __v_488); if (__v_489 != __v_488) { return Err(ExecError::AssertEqMismatch { lhs: __v_489.as_canonical_u64(), rhs: __v_488.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_328, &__v_484)?; Bytes2::xor_split4(&__v_328, &__v_484) } else { bytes2_xor_split4_value(__v_328, __v_484, record)? }; let __v_490: G = __b2_out.0; let __v_491: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_329, &__v_485)?; Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record)? }; let __v_492: G = __b2_out.0; let __v_493: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_330, &__v_486)?; Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record)? }; let __v_494: G = __b2_out.0; let __v_495: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_331, &__v_487)?; Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record)? }; let __v_496: G = __b2_out.0; let __v_497: G = __b2_out.1; let __v_498: G = (__v_492 + __v_495); @@ -6345,8 +6421,8 @@ fn aiur_fn_74( let __v_504: G = G::from_u8(__u32_bytes[2]); let __v_505: G = G::from_u8(__u32_bytes[3]); let __v_506: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_502; let __vj = __v_503; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_504; let __vj = __v_505; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_502; let __vj = __v_503; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_504; let __vj = __v_505; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_507: G = G::from_u64(1); let __v_508: G = (__v_506 - __v_507); let __v_509: G = G::from_u64(2); @@ -6357,10 +6433,10 @@ fn aiur_fn_74( if (__v_512 != __v_513) { return Err(ExecError::AssertEqMismatch { lhs: __v_512.as_canonical_u64(), rhs: __v_513.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_514: G = if unconstrained { Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record) }; - let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) }; - let __v_516: G = if unconstrained { Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record) }; - let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) }; + let __v_514: G = if unconstrained { Bytes2::validate_inputs(&__v_482, &__v_502)?; Bytes2::xor(&__v_482, &__v_502) } else { bytes2_xor_value(__v_482, __v_502, record)? }; + let __v_515: G = if unconstrained { Bytes2::validate_inputs(&__v_483, &__v_503)?; Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record)? }; + let __v_516: G = if unconstrained { Bytes2::validate_inputs(&__v_480, &__v_504)?; Bytes2::xor(&__v_480, &__v_504) } else { bytes2_xor_value(__v_480, __v_504, record)? }; + let __v_517: G = if unconstrained { Bytes2::validate_inputs(&__v_481, &__v_505)?; Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record)? }; let __u32_sum: u128 = u128::from(((__v_484.as_canonical_u64() << 0) | (__v_485.as_canonical_u64() << 8) | (__v_486.as_canonical_u64() << 16) | (__v_487.as_canonical_u64() << 24))) + u128::from(((__v_515.as_canonical_u64() << 0) | (__v_516.as_canonical_u64() << 8) | (__v_517.as_canonical_u64() << 16) | (__v_514.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_518: G = G::from_u8(__u32_bytes[0]); @@ -6368,22 +6444,22 @@ fn aiur_fn_74( let __v_520: G = G::from_u8(__u32_bytes[2]); let __v_521: G = G::from_u8(__u32_bytes[3]); let __v_522: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_518; let __vj = __v_519; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_520; let __vj = __v_521; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_518; let __vj = __v_519; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_520; let __vj = __v_521; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_523: G = (__v_522 * __v_522); if (__v_523 != __v_522) { return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_522.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_498, &__v_518)?; Bytes2::xor_split7(&__v_498, &__v_518) } else { bytes2_xor_split7_value(__v_498, __v_518, record)? }; let __v_524: G = __b2_out.0; let __v_525: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_499, &__v_519)?; Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record)? }; let __v_526: G = __b2_out.0; let __v_527: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_500, &__v_520)?; Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record)? }; let __v_528: G = __b2_out.0; let __v_529: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_501, &__v_521)?; Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record)? }; let __v_530: G = __b2_out.0; let __v_531: G = __b2_out.1; let __v_532: G = (__v_524 + __v_527); @@ -6397,8 +6473,8 @@ fn aiur_fn_74( let __v_538: G = G::from_u8(__u32_bytes[2]); let __v_539: G = G::from_u8(__u32_bytes[3]); let __v_540: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_536; let __vj = __v_537; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_538; let __vj = __v_539; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_536; let __vj = __v_537; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_538; let __vj = __v_539; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_541: G = G::from_u64(1); let __v_542: G = (__v_540 - __v_541); let __v_543: G = G::from_u64(2); @@ -6409,10 +6485,10 @@ fn aiur_fn_74( if (__v_546 != __v_547) { return Err(ExecError::AssertEqMismatch { lhs: __v_546.as_canonical_u64(), rhs: __v_547.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_548: G = if unconstrained { Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record) }; - let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) }; - let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) }; - let __v_551: G = if unconstrained { Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record) }; + let __v_548: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_536)?; Bytes2::xor(&__v_243, &__v_536) } else { bytes2_xor_value(__v_243, __v_536, record)? }; + let __v_549: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_537)?; Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record)? }; + let __v_550: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_538)?; Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record)? }; + let __v_551: G = if unconstrained { Bytes2::validate_inputs(&__v_242, &__v_539)?; Bytes2::xor(&__v_242, &__v_539) } else { bytes2_xor_value(__v_242, __v_539, record)? }; let __u32_sum: u128 = u128::from(((__v_178.as_canonical_u64() << 0) | (__v_179.as_canonical_u64() << 8) | (__v_180.as_canonical_u64() << 16) | (__v_181.as_canonical_u64() << 24))) + u128::from(((__v_550.as_canonical_u64() << 0) | (__v_551.as_canonical_u64() << 8) | (__v_548.as_canonical_u64() << 16) | (__v_549.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_552: G = G::from_u8(__u32_bytes[0]); @@ -6420,22 +6496,22 @@ fn aiur_fn_74( let __v_554: G = G::from_u8(__u32_bytes[2]); let __v_555: G = G::from_u8(__u32_bytes[3]); let __v_556: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_552; let __vj = __v_553; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_554; let __vj = __v_555; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_552; let __vj = __v_553; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_554; let __vj = __v_555; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_557: G = (__v_556 * __v_556); if (__v_557 != __v_556) { return Err(ExecError::AssertEqMismatch { lhs: __v_557.as_canonical_u64(), rhs: __v_556.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_396, &__v_552)?; Bytes2::xor_split4(&__v_396, &__v_552) } else { bytes2_xor_split4_value(__v_396, __v_552, record)? }; let __v_558: G = __b2_out.0; let __v_559: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_553)?; Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record)? }; let __v_560: G = __b2_out.0; let __v_561: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_398, &__v_554)?; Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record)? }; let __v_562: G = __b2_out.0; let __v_563: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_399, &__v_555)?; Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record)? }; let __v_564: G = __b2_out.0; let __v_565: G = __b2_out.1; let __v_566: G = (__v_560 + __v_563); @@ -6449,8 +6525,8 @@ fn aiur_fn_74( let __v_572: G = G::from_u8(__u32_bytes[2]); let __v_573: G = G::from_u8(__u32_bytes[3]); let __v_574: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_570; let __vj = __v_571; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_572; let __vj = __v_573; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_570; let __vj = __v_571; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_572; let __vj = __v_573; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_575: G = G::from_u64(1); let __v_576: G = (__v_574 - __v_575); let __v_577: G = G::from_u64(2); @@ -6461,10 +6537,10 @@ fn aiur_fn_74( if (__v_580 != __v_581) { return Err(ExecError::AssertEqMismatch { lhs: __v_580.as_canonical_u64(), rhs: __v_581.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_582: G = if unconstrained { Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record) }; - let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) }; - let __v_584: G = if unconstrained { Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record) }; - let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) }; + let __v_582: G = if unconstrained { Bytes2::validate_inputs(&__v_550, &__v_570)?; Bytes2::xor(&__v_550, &__v_570) } else { bytes2_xor_value(__v_550, __v_570, record)? }; + let __v_583: G = if unconstrained { Bytes2::validate_inputs(&__v_551, &__v_571)?; Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record)? }; + let __v_584: G = if unconstrained { Bytes2::validate_inputs(&__v_548, &__v_572)?; Bytes2::xor(&__v_548, &__v_572) } else { bytes2_xor_value(__v_548, __v_572, record)? }; + let __v_585: G = if unconstrained { Bytes2::validate_inputs(&__v_549, &__v_573)?; Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record)? }; let __u32_sum: u128 = u128::from(((__v_552.as_canonical_u64() << 0) | (__v_553.as_canonical_u64() << 8) | (__v_554.as_canonical_u64() << 16) | (__v_555.as_canonical_u64() << 24))) + u128::from(((__v_583.as_canonical_u64() << 0) | (__v_584.as_canonical_u64() << 8) | (__v_585.as_canonical_u64() << 16) | (__v_582.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_586: G = G::from_u8(__u32_bytes[0]); @@ -6472,22 +6548,22 @@ fn aiur_fn_74( let __v_588: G = G::from_u8(__u32_bytes[2]); let __v_589: G = G::from_u8(__u32_bytes[3]); let __v_590: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_586; let __vj = __v_587; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_588; let __vj = __v_589; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_586; let __vj = __v_587; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_588; let __vj = __v_589; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_591: G = (__v_590 * __v_590); if (__v_591 != __v_590) { return Err(ExecError::AssertEqMismatch { lhs: __v_591.as_canonical_u64(), rhs: __v_590.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_566, &__v_586)?; Bytes2::xor_split7(&__v_566, &__v_586) } else { bytes2_xor_split7_value(__v_566, __v_586, record)? }; let __v_592: G = __b2_out.0; let __v_593: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_567, &__v_587)?; Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record)? }; let __v_594: G = __b2_out.0; let __v_595: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_568, &__v_588)?; Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record)? }; let __v_596: G = __b2_out.0; let __v_597: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_569, &__v_589)?; Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record)? }; let __v_598: G = __b2_out.0; let __v_599: G = __b2_out.1; let __v_600: G = (__v_592 + __v_595); @@ -6501,8 +6577,8 @@ fn aiur_fn_74( let __v_606: G = G::from_u8(__u32_bytes[2]); let __v_607: G = G::from_u8(__u32_bytes[3]); let __v_608: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_604; let __vj = __v_605; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_606; let __vj = __v_607; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_604; let __vj = __v_605; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_606; let __vj = __v_607; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_609: G = G::from_u64(1); let __v_610: G = (__v_608 - __v_609); let __v_611: G = G::from_u64(2); @@ -6513,10 +6589,10 @@ fn aiur_fn_74( if (__v_614 != __v_615) { return Err(ExecError::AssertEqMismatch { lhs: __v_614.as_canonical_u64(), rhs: __v_615.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_616: G = if unconstrained { Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record) }; - let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) }; - let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) }; - let __v_619: G = if unconstrained { Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record) }; + let __v_616: G = if unconstrained { Bytes2::validate_inputs(&__v_311, &__v_604)?; Bytes2::xor(&__v_311, &__v_604) } else { bytes2_xor_value(__v_311, __v_604, record)? }; + let __v_617: G = if unconstrained { Bytes2::validate_inputs(&__v_312, &__v_605)?; Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record)? }; + let __v_618: G = if unconstrained { Bytes2::validate_inputs(&__v_313, &__v_606)?; Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record)? }; + let __v_619: G = if unconstrained { Bytes2::validate_inputs(&__v_310, &__v_607)?; Bytes2::xor(&__v_310, &__v_607) } else { bytes2_xor_value(__v_310, __v_607, record)? }; let __u32_sum: u128 = u128::from(((__v_246.as_canonical_u64() << 0) | (__v_247.as_canonical_u64() << 8) | (__v_248.as_canonical_u64() << 16) | (__v_249.as_canonical_u64() << 24))) + u128::from(((__v_618.as_canonical_u64() << 0) | (__v_619.as_canonical_u64() << 8) | (__v_616.as_canonical_u64() << 16) | (__v_617.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_620: G = G::from_u8(__u32_bytes[0]); @@ -6524,22 +6600,22 @@ fn aiur_fn_74( let __v_622: G = G::from_u8(__u32_bytes[2]); let __v_623: G = G::from_u8(__u32_bytes[3]); let __v_624: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_620; let __vj = __v_621; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_622; let __vj = __v_623; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_620; let __vj = __v_621; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_622; let __vj = __v_623; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_625: G = (__v_624 * __v_624); if (__v_625 != __v_624) { return Err(ExecError::AssertEqMismatch { lhs: __v_625.as_canonical_u64(), rhs: __v_624.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_192, &__v_620)?; Bytes2::xor_split4(&__v_192, &__v_620) } else { bytes2_xor_split4_value(__v_192, __v_620, record)? }; let __v_626: G = __b2_out.0; let __v_627: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_193, &__v_621)?; Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record)? }; let __v_628: G = __b2_out.0; let __v_629: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_194, &__v_622)?; Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record)? }; let __v_630: G = __b2_out.0; let __v_631: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_195, &__v_623)?; Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record)? }; let __v_632: G = __b2_out.0; let __v_633: G = __b2_out.1; let __v_634: G = (__v_628 + __v_631); @@ -6553,8 +6629,8 @@ fn aiur_fn_74( let __v_640: G = G::from_u8(__u32_bytes[2]); let __v_641: G = G::from_u8(__u32_bytes[3]); let __v_642: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_638; let __vj = __v_639; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_640; let __vj = __v_641; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_638; let __vj = __v_639; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_640; let __vj = __v_641; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_643: G = G::from_u64(1); let __v_644: G = (__v_642 - __v_643); let __v_645: G = G::from_u64(2); @@ -6565,10 +6641,10 @@ fn aiur_fn_74( if (__v_648 != __v_649) { return Err(ExecError::AssertEqMismatch { lhs: __v_648.as_canonical_u64(), rhs: __v_649.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_650: G = if unconstrained { Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record) }; - let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) }; - let __v_652: G = if unconstrained { Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record) }; - let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) }; + let __v_650: G = if unconstrained { Bytes2::validate_inputs(&__v_618, &__v_638)?; Bytes2::xor(&__v_618, &__v_638) } else { bytes2_xor_value(__v_618, __v_638, record)? }; + let __v_651: G = if unconstrained { Bytes2::validate_inputs(&__v_619, &__v_639)?; Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record)? }; + let __v_652: G = if unconstrained { Bytes2::validate_inputs(&__v_616, &__v_640)?; Bytes2::xor(&__v_616, &__v_640) } else { bytes2_xor_value(__v_616, __v_640, record)? }; + let __v_653: G = if unconstrained { Bytes2::validate_inputs(&__v_617, &__v_641)?; Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record)? }; let __u32_sum: u128 = u128::from(((__v_620.as_canonical_u64() << 0) | (__v_621.as_canonical_u64() << 8) | (__v_622.as_canonical_u64() << 16) | (__v_623.as_canonical_u64() << 24))) + u128::from(((__v_651.as_canonical_u64() << 0) | (__v_652.as_canonical_u64() << 8) | (__v_653.as_canonical_u64() << 16) | (__v_650.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_654: G = G::from_u8(__u32_bytes[0]); @@ -6576,22 +6652,22 @@ fn aiur_fn_74( let __v_656: G = G::from_u8(__u32_bytes[2]); let __v_657: G = G::from_u8(__u32_bytes[3]); let __v_658: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_654; let __vj = __v_655; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_656; let __vj = __v_657; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_654; let __vj = __v_655; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_656; let __vj = __v_657; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_659: G = (__v_658 * __v_658); if (__v_659 != __v_658) { return Err(ExecError::AssertEqMismatch { lhs: __v_659.as_canonical_u64(), rhs: __v_658.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_634, &__v_654)?; Bytes2::xor_split7(&__v_634, &__v_654) } else { bytes2_xor_split7_value(__v_634, __v_654, record)? }; let __v_660: G = __b2_out.0; let __v_661: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_635, &__v_655)?; Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record)? }; let __v_662: G = __b2_out.0; let __v_663: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_636, &__v_656)?; Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record)? }; let __v_664: G = __b2_out.0; let __v_665: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_637, &__v_657)?; Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record)? }; let __v_666: G = __b2_out.0; let __v_667: G = __b2_out.1; let __v_668: G = (__v_660 + __v_663); @@ -6599,7 +6675,7 @@ fn aiur_fn_74( let __v_670: G = (__v_664 + __v_667); let __v_671: G = (__v_666 + __v_661); let __ret: [G; OUT_74] = [__v_434, __v_435, __v_436, __v_437, __v_502, __v_503, __v_504, __v_505, __v_570, __v_571, __v_572, __v_573, __v_638, __v_639, __v_640, __v_641, __v_668, __v_669, __v_670, __v_671, __v_464, __v_465, __v_466, __v_467, __v_532, __v_533, __v_534, __v_535, __v_600, __v_601, __v_602, __v_603, __v_586, __v_587, __v_588, __v_589, __v_654, __v_655, __v_656, __v_657, __v_450, __v_451, __v_452, __v_453, __v_518, __v_519, __v_520, __v_521, __v_515, __v_516, __v_517, __v_514, __v_583, __v_584, __v_585, __v_582, __v_651, __v_652, __v_653, __v_650, __v_447, __v_448, __v_449, __v_446, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; - record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[74].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -6608,118 +6684,119 @@ const INPUT_SIZE_75: usize = 106; const IN_75: usize = 106; const OUT_75: usize = 32; fn aiur_fn_75( - inp: [G; IN_75], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_75], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; + record.checkpoint(75); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; let __v_106: G = G::from_u64(103); let __v_107: G = G::from_u64(230); let __v_108: G = G::from_u64(9); @@ -6743,7 +6820,7 @@ fn aiur_fn_75( let __v_126: G = G::from_u64(0); let __v_127: G = G::from_u64(0); let __v_128: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_128, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_122, __v_123, __v_124, __v_105, __v_125, __v_126, __v_127, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -6777,7 +6854,7 @@ fn aiur_fn_75( let __v_159: G = __r_arr[30]; let __v_160: G = __r_arr[31]; let __ret: [G; OUT_75] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[75].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -6786,177 +6863,178 @@ const INPUT_SIZE_76: usize = 129; const IN_76: usize = 129; const OUT_76: usize = 32; fn aiur_fn_76( - inp: [G; IN_76], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_76], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; - let __v_57: G = inp[57]; - let __v_58: G = inp[58]; - let __v_59: G = inp[59]; - let __v_60: G = inp[60]; - let __v_61: G = inp[61]; - let __v_62: G = inp[62]; - let __v_63: G = inp[63]; - let __v_64: G = inp[64]; - let __v_65: G = inp[65]; - let __v_66: G = inp[66]; - let __v_67: G = inp[67]; - let __v_68: G = inp[68]; - let __v_69: G = inp[69]; - let __v_70: G = inp[70]; - let __v_71: G = inp[71]; - let __v_72: G = inp[72]; - let __v_73: G = inp[73]; - let __v_74: G = inp[74]; - let __v_75: G = inp[75]; - let __v_76: G = inp[76]; - let __v_77: G = inp[77]; - let __v_78: G = inp[78]; - let __v_79: G = inp[79]; - let __v_80: G = inp[80]; - let __v_81: G = inp[81]; - let __v_82: G = inp[82]; - let __v_83: G = inp[83]; - let __v_84: G = inp[84]; - let __v_85: G = inp[85]; - let __v_86: G = inp[86]; - let __v_87: G = inp[87]; - let __v_88: G = inp[88]; - let __v_89: G = inp[89]; - let __v_90: G = inp[90]; - let __v_91: G = inp[91]; - let __v_92: G = inp[92]; - let __v_93: G = inp[93]; - let __v_94: G = inp[94]; - let __v_95: G = inp[95]; - let __v_96: G = inp[96]; - let __v_97: G = inp[97]; - let __v_98: G = inp[98]; - let __v_99: G = inp[99]; - let __v_100: G = inp[100]; - let __v_101: G = inp[101]; - let __v_102: G = inp[102]; - let __v_103: G = inp[103]; - let __v_104: G = inp[104]; - let __v_105: G = inp[105]; - let __v_106: G = inp[106]; - let __v_107: G = inp[107]; - let __v_108: G = inp[108]; - let __v_109: G = inp[109]; - let __v_110: G = inp[110]; - let __v_111: G = inp[111]; - let __v_112: G = inp[112]; - let __v_113: G = inp[113]; - let __v_114: G = inp[114]; - let __v_115: G = inp[115]; - let __v_116: G = inp[116]; - let __v_117: G = inp[117]; - let __v_118: G = inp[118]; - let __v_119: G = inp[119]; - let __v_120: G = inp[120]; - let __v_121: G = inp[121]; - let __v_122: G = inp[122]; - let __v_123: G = inp[123]; - let __v_124: G = inp[124]; - let __v_125: G = inp[125]; - let __v_126: G = inp[126]; - let __v_127: G = inp[127]; - let __v_128: G = inp[128]; + record.checkpoint(76); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; + let __v_57: G = inp.values()[57]; + let __v_58: G = inp.values()[58]; + let __v_59: G = inp.values()[59]; + let __v_60: G = inp.values()[60]; + let __v_61: G = inp.values()[61]; + let __v_62: G = inp.values()[62]; + let __v_63: G = inp.values()[63]; + let __v_64: G = inp.values()[64]; + let __v_65: G = inp.values()[65]; + let __v_66: G = inp.values()[66]; + let __v_67: G = inp.values()[67]; + let __v_68: G = inp.values()[68]; + let __v_69: G = inp.values()[69]; + let __v_70: G = inp.values()[70]; + let __v_71: G = inp.values()[71]; + let __v_72: G = inp.values()[72]; + let __v_73: G = inp.values()[73]; + let __v_74: G = inp.values()[74]; + let __v_75: G = inp.values()[75]; + let __v_76: G = inp.values()[76]; + let __v_77: G = inp.values()[77]; + let __v_78: G = inp.values()[78]; + let __v_79: G = inp.values()[79]; + let __v_80: G = inp.values()[80]; + let __v_81: G = inp.values()[81]; + let __v_82: G = inp.values()[82]; + let __v_83: G = inp.values()[83]; + let __v_84: G = inp.values()[84]; + let __v_85: G = inp.values()[85]; + let __v_86: G = inp.values()[86]; + let __v_87: G = inp.values()[87]; + let __v_88: G = inp.values()[88]; + let __v_89: G = inp.values()[89]; + let __v_90: G = inp.values()[90]; + let __v_91: G = inp.values()[91]; + let __v_92: G = inp.values()[92]; + let __v_93: G = inp.values()[93]; + let __v_94: G = inp.values()[94]; + let __v_95: G = inp.values()[95]; + let __v_96: G = inp.values()[96]; + let __v_97: G = inp.values()[97]; + let __v_98: G = inp.values()[98]; + let __v_99: G = inp.values()[99]; + let __v_100: G = inp.values()[100]; + let __v_101: G = inp.values()[101]; + let __v_102: G = inp.values()[102]; + let __v_103: G = inp.values()[103]; + let __v_104: G = inp.values()[104]; + let __v_105: G = inp.values()[105]; + let __v_106: G = inp.values()[106]; + let __v_107: G = inp.values()[107]; + let __v_108: G = inp.values()[108]; + let __v_109: G = inp.values()[109]; + let __v_110: G = inp.values()[110]; + let __v_111: G = inp.values()[111]; + let __v_112: G = inp.values()[112]; + let __v_113: G = inp.values()[113]; + let __v_114: G = inp.values()[114]; + let __v_115: G = inp.values()[115]; + let __v_116: G = inp.values()[116]; + let __v_117: G = inp.values()[117]; + let __v_118: G = inp.values()[118]; + let __v_119: G = inp.values()[119]; + let __v_120: G = inp.values()[120]; + let __v_121: G = inp.values()[121]; + let __v_122: G = inp.values()[122]; + let __v_123: G = inp.values()[123]; + let __v_124: G = inp.values()[124]; + let __v_125: G = inp.values()[125]; + let __v_126: G = inp.values()[126]; + let __v_127: G = inp.values()[127]; + let __v_128: G = inp.values()[128]; match __v_0.as_canonical_u64() { 7u64 => { - let __v_129: G = if unconstrained { Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record) }; - let __v_130: G = if unconstrained { Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record) }; - let __v_131: G = if unconstrained { Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record) }; - let __v_132: G = if unconstrained { Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record) }; - let __v_133: G = if unconstrained { Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record) }; - let __v_134: G = if unconstrained { Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record) }; - let __v_135: G = if unconstrained { Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record) }; - let __v_136: G = if unconstrained { Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record) }; - let __v_137: G = if unconstrained { Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record) }; - let __v_138: G = if unconstrained { Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record) }; - let __v_139: G = if unconstrained { Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record) }; - let __v_140: G = if unconstrained { Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record) }; - let __v_141: G = if unconstrained { Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record) }; - let __v_144: G = if unconstrained { Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record) }; - let __v_145: G = if unconstrained { Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record) }; - let __v_146: G = if unconstrained { Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record) }; - let __v_147: G = if unconstrained { Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record) }; - let __v_148: G = if unconstrained { Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record) }; - let __v_149: G = if unconstrained { Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record) }; - let __v_150: G = if unconstrained { Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record) }; - let __v_151: G = if unconstrained { Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record) }; - let __v_152: G = if unconstrained { Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record) }; - let __v_153: G = if unconstrained { Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record) }; - let __v_154: G = if unconstrained { Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record) }; - let __v_155: G = if unconstrained { Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record) }; - let __v_156: G = if unconstrained { Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record) }; - let __v_157: G = if unconstrained { Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record) }; - let __v_158: G = if unconstrained { Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record) }; - let __v_159: G = if unconstrained { Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record) }; - let __v_160: G = if unconstrained { Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record) }; + let __v_129: G = if unconstrained { Bytes2::validate_inputs(&__v_1, &__v_33)?; Bytes2::xor(&__v_1, &__v_33) } else { bytes2_xor_value(__v_1, __v_33, record)? }; + let __v_130: G = if unconstrained { Bytes2::validate_inputs(&__v_2, &__v_34)?; Bytes2::xor(&__v_2, &__v_34) } else { bytes2_xor_value(__v_2, __v_34, record)? }; + let __v_131: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_35)?; Bytes2::xor(&__v_3, &__v_35) } else { bytes2_xor_value(__v_3, __v_35, record)? }; + let __v_132: G = if unconstrained { Bytes2::validate_inputs(&__v_4, &__v_36)?; Bytes2::xor(&__v_4, &__v_36) } else { bytes2_xor_value(__v_4, __v_36, record)? }; + let __v_133: G = if unconstrained { Bytes2::validate_inputs(&__v_5, &__v_37)?; Bytes2::xor(&__v_5, &__v_37) } else { bytes2_xor_value(__v_5, __v_37, record)? }; + let __v_134: G = if unconstrained { Bytes2::validate_inputs(&__v_6, &__v_38)?; Bytes2::xor(&__v_6, &__v_38) } else { bytes2_xor_value(__v_6, __v_38, record)? }; + let __v_135: G = if unconstrained { Bytes2::validate_inputs(&__v_7, &__v_39)?; Bytes2::xor(&__v_7, &__v_39) } else { bytes2_xor_value(__v_7, __v_39, record)? }; + let __v_136: G = if unconstrained { Bytes2::validate_inputs(&__v_8, &__v_40)?; Bytes2::xor(&__v_8, &__v_40) } else { bytes2_xor_value(__v_8, __v_40, record)? }; + let __v_137: G = if unconstrained { Bytes2::validate_inputs(&__v_9, &__v_41)?; Bytes2::xor(&__v_9, &__v_41) } else { bytes2_xor_value(__v_9, __v_41, record)? }; + let __v_138: G = if unconstrained { Bytes2::validate_inputs(&__v_10, &__v_42)?; Bytes2::xor(&__v_10, &__v_42) } else { bytes2_xor_value(__v_10, __v_42, record)? }; + let __v_139: G = if unconstrained { Bytes2::validate_inputs(&__v_11, &__v_43)?; Bytes2::xor(&__v_11, &__v_43) } else { bytes2_xor_value(__v_11, __v_43, record)? }; + let __v_140: G = if unconstrained { Bytes2::validate_inputs(&__v_12, &__v_44)?; Bytes2::xor(&__v_12, &__v_44) } else { bytes2_xor_value(__v_12, __v_44, record)? }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_13, &__v_45)?; Bytes2::xor(&__v_13, &__v_45) } else { bytes2_xor_value(__v_13, __v_45, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_14, &__v_46)?; Bytes2::xor(&__v_14, &__v_46) } else { bytes2_xor_value(__v_14, __v_46, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_15, &__v_47)?; Bytes2::xor(&__v_15, &__v_47) } else { bytes2_xor_value(__v_15, __v_47, record)? }; + let __v_144: G = if unconstrained { Bytes2::validate_inputs(&__v_16, &__v_48)?; Bytes2::xor(&__v_16, &__v_48) } else { bytes2_xor_value(__v_16, __v_48, record)? }; + let __v_145: G = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_49)?; Bytes2::xor(&__v_17, &__v_49) } else { bytes2_xor_value(__v_17, __v_49, record)? }; + let __v_146: G = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_50)?; Bytes2::xor(&__v_18, &__v_50) } else { bytes2_xor_value(__v_18, __v_50, record)? }; + let __v_147: G = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_51)?; Bytes2::xor(&__v_19, &__v_51) } else { bytes2_xor_value(__v_19, __v_51, record)? }; + let __v_148: G = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_52)?; Bytes2::xor(&__v_20, &__v_52) } else { bytes2_xor_value(__v_20, __v_52, record)? }; + let __v_149: G = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_53)?; Bytes2::xor(&__v_21, &__v_53) } else { bytes2_xor_value(__v_21, __v_53, record)? }; + let __v_150: G = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_54)?; Bytes2::xor(&__v_22, &__v_54) } else { bytes2_xor_value(__v_22, __v_54, record)? }; + let __v_151: G = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_55)?; Bytes2::xor(&__v_23, &__v_55) } else { bytes2_xor_value(__v_23, __v_55, record)? }; + let __v_152: G = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_56)?; Bytes2::xor(&__v_24, &__v_56) } else { bytes2_xor_value(__v_24, __v_56, record)? }; + let __v_153: G = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_57)?; Bytes2::xor(&__v_25, &__v_57) } else { bytes2_xor_value(__v_25, __v_57, record)? }; + let __v_154: G = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_58)?; Bytes2::xor(&__v_26, &__v_58) } else { bytes2_xor_value(__v_26, __v_58, record)? }; + let __v_155: G = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_59)?; Bytes2::xor(&__v_27, &__v_59) } else { bytes2_xor_value(__v_27, __v_59, record)? }; + let __v_156: G = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_60)?; Bytes2::xor(&__v_28, &__v_60) } else { bytes2_xor_value(__v_28, __v_60, record)? }; + let __v_157: G = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_61)?; Bytes2::xor(&__v_29, &__v_61) } else { bytes2_xor_value(__v_29, __v_61, record)? }; + let __v_158: G = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_62)?; Bytes2::xor(&__v_30, &__v_62) } else { bytes2_xor_value(__v_30, __v_62, record)? }; + let __v_159: G = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_63)?; Bytes2::xor(&__v_31, &__v_63) } else { bytes2_xor_value(__v_31, __v_63, record)? }; + let __v_160: G = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_64)?; Bytes2::xor(&__v_32, &__v_64) } else { bytes2_xor_value(__v_32, __v_64, record)? }; let __ret: [G; OUT_76] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160]; - record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[76].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -6967,8 +7045,8 @@ fn aiur_fn_76( let __v_131: G = G::from_u8(__u32_bytes[2]); let __v_132: G = G::from_u8(__u32_bytes[3]); let __v_133: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_129; let __vj = __v_130; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_131; let __vj = __v_132; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_129; let __vj = __v_130; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_131; let __vj = __v_132; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_134: G = G::from_u64(1); let __v_135: G = (__v_133 - __v_134); let __v_136: G = G::from_u64(2); @@ -6979,10 +7057,10 @@ fn aiur_fn_76( if (__v_139 != __v_140) { return Err(ExecError::AssertEqMismatch { lhs: __v_139.as_canonical_u64(), rhs: __v_140.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_141: G = if unconstrained { Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record) }; - let __v_142: G = if unconstrained { Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record) }; - let __v_143: G = if unconstrained { Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record) }; - let __v_144: G = if unconstrained { Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record) }; + let __v_141: G = if unconstrained { Bytes2::validate_inputs(&__v_49, &__v_129)?; Bytes2::xor(&__v_49, &__v_129) } else { bytes2_xor_value(__v_49, __v_129, record)? }; + let __v_142: G = if unconstrained { Bytes2::validate_inputs(&__v_50, &__v_130)?; Bytes2::xor(&__v_50, &__v_130) } else { bytes2_xor_value(__v_50, __v_130, record)? }; + let __v_143: G = if unconstrained { Bytes2::validate_inputs(&__v_51, &__v_131)?; Bytes2::xor(&__v_51, &__v_131) } else { bytes2_xor_value(__v_51, __v_131, record)? }; + let __v_144: G = if unconstrained { Bytes2::validate_inputs(&__v_52, &__v_132)?; Bytes2::xor(&__v_52, &__v_132) } else { bytes2_xor_value(__v_52, __v_132, record)? }; let __u32_sum: u128 = u128::from(((__v_33.as_canonical_u64() << 0) | (__v_34.as_canonical_u64() << 8) | (__v_35.as_canonical_u64() << 16) | (__v_36.as_canonical_u64() << 24))) + u128::from(((__v_143.as_canonical_u64() << 0) | (__v_144.as_canonical_u64() << 8) | (__v_141.as_canonical_u64() << 16) | (__v_142.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_145: G = G::from_u8(__u32_bytes[0]); @@ -6990,22 +7068,22 @@ fn aiur_fn_76( let __v_147: G = G::from_u8(__u32_bytes[2]); let __v_148: G = G::from_u8(__u32_bytes[3]); let __v_149: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_145; let __vj = __v_146; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_147; let __vj = __v_148; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_145; let __vj = __v_146; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_147; let __vj = __v_148; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_150: G = (__v_149 * __v_149); if (__v_150 != __v_149) { return Err(ExecError::AssertEqMismatch { lhs: __v_150.as_canonical_u64(), rhs: __v_149.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_17, &__v_145)?; Bytes2::xor_split4(&__v_17, &__v_145) } else { bytes2_xor_split4_value(__v_17, __v_145, record)? }; let __v_151: G = __b2_out.0; let __v_152: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_18, &__v_146)?; Bytes2::xor_split4(&__v_18, &__v_146) } else { bytes2_xor_split4_value(__v_18, __v_146, record)? }; let __v_153: G = __b2_out.0; let __v_154: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_19, &__v_147)?; Bytes2::xor_split4(&__v_19, &__v_147) } else { bytes2_xor_split4_value(__v_19, __v_147, record)? }; let __v_155: G = __b2_out.0; let __v_156: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_20, &__v_148)?; Bytes2::xor_split4(&__v_20, &__v_148) } else { bytes2_xor_split4_value(__v_20, __v_148, record)? }; let __v_157: G = __b2_out.0; let __v_158: G = __b2_out.1; let __v_159: G = (__v_153 + __v_156); @@ -7019,8 +7097,8 @@ fn aiur_fn_76( let __v_165: G = G::from_u8(__u32_bytes[2]); let __v_166: G = G::from_u8(__u32_bytes[3]); let __v_167: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_163; let __vj = __v_164; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_165; let __vj = __v_166; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_163; let __vj = __v_164; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_165; let __vj = __v_166; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_168: G = G::from_u64(1); let __v_169: G = (__v_167 - __v_168); let __v_170: G = G::from_u64(2); @@ -7031,10 +7109,10 @@ fn aiur_fn_76( if (__v_173 != __v_174) { return Err(ExecError::AssertEqMismatch { lhs: __v_173.as_canonical_u64(), rhs: __v_174.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_175: G = if unconstrained { Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record) }; - let __v_176: G = if unconstrained { Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record) }; - let __v_177: G = if unconstrained { Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record) }; - let __v_178: G = if unconstrained { Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record) }; + let __v_175: G = if unconstrained { Bytes2::validate_inputs(&__v_143, &__v_163)?; Bytes2::xor(&__v_143, &__v_163) } else { bytes2_xor_value(__v_143, __v_163, record)? }; + let __v_176: G = if unconstrained { Bytes2::validate_inputs(&__v_144, &__v_164)?; Bytes2::xor(&__v_144, &__v_164) } else { bytes2_xor_value(__v_144, __v_164, record)? }; + let __v_177: G = if unconstrained { Bytes2::validate_inputs(&__v_141, &__v_165)?; Bytes2::xor(&__v_141, &__v_165) } else { bytes2_xor_value(__v_141, __v_165, record)? }; + let __v_178: G = if unconstrained { Bytes2::validate_inputs(&__v_142, &__v_166)?; Bytes2::xor(&__v_142, &__v_166) } else { bytes2_xor_value(__v_142, __v_166, record)? }; let __u32_sum: u128 = u128::from(((__v_145.as_canonical_u64() << 0) | (__v_146.as_canonical_u64() << 8) | (__v_147.as_canonical_u64() << 16) | (__v_148.as_canonical_u64() << 24))) + u128::from(((__v_176.as_canonical_u64() << 0) | (__v_177.as_canonical_u64() << 8) | (__v_178.as_canonical_u64() << 16) | (__v_175.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_179: G = G::from_u8(__u32_bytes[0]); @@ -7042,22 +7120,22 @@ fn aiur_fn_76( let __v_181: G = G::from_u8(__u32_bytes[2]); let __v_182: G = G::from_u8(__u32_bytes[3]); let __v_183: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_179; let __vj = __v_180; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_181; let __vj = __v_182; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_179; let __vj = __v_180; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_181; let __vj = __v_182; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_184: G = (__v_183 * __v_183); if (__v_184 != __v_183) { return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_183.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_159, &__v_179)?; Bytes2::xor_split7(&__v_159, &__v_179) } else { bytes2_xor_split7_value(__v_159, __v_179, record)? }; let __v_185: G = __b2_out.0; let __v_186: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_160, &__v_180)?; Bytes2::xor_split7(&__v_160, &__v_180) } else { bytes2_xor_split7_value(__v_160, __v_180, record)? }; let __v_187: G = __b2_out.0; let __v_188: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_161, &__v_181)?; Bytes2::xor_split7(&__v_161, &__v_181) } else { bytes2_xor_split7_value(__v_161, __v_181, record)? }; let __v_189: G = __b2_out.0; let __v_190: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_162, &__v_182)?; Bytes2::xor_split7(&__v_162, &__v_182) } else { bytes2_xor_split7_value(__v_162, __v_182, record)? }; let __v_191: G = __b2_out.0; let __v_192: G = __b2_out.1; let __v_193: G = (__v_185 + __v_188); @@ -7071,8 +7149,8 @@ fn aiur_fn_76( let __v_199: G = G::from_u8(__u32_bytes[2]); let __v_200: G = G::from_u8(__u32_bytes[3]); let __v_201: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_197; let __vj = __v_198; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_199; let __vj = __v_200; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_197; let __vj = __v_198; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_199; let __vj = __v_200; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_202: G = G::from_u64(1); let __v_203: G = (__v_201 - __v_202); let __v_204: G = G::from_u64(2); @@ -7083,10 +7161,10 @@ fn aiur_fn_76( if (__v_207 != __v_208) { return Err(ExecError::AssertEqMismatch { lhs: __v_207.as_canonical_u64(), rhs: __v_208.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_209: G = if unconstrained { Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record) }; - let __v_210: G = if unconstrained { Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record) }; - let __v_211: G = if unconstrained { Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record) }; - let __v_212: G = if unconstrained { Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record) }; + let __v_209: G = if unconstrained { Bytes2::validate_inputs(&__v_53, &__v_197)?; Bytes2::xor(&__v_53, &__v_197) } else { bytes2_xor_value(__v_53, __v_197, record)? }; + let __v_210: G = if unconstrained { Bytes2::validate_inputs(&__v_54, &__v_198)?; Bytes2::xor(&__v_54, &__v_198) } else { bytes2_xor_value(__v_54, __v_198, record)? }; + let __v_211: G = if unconstrained { Bytes2::validate_inputs(&__v_55, &__v_199)?; Bytes2::xor(&__v_55, &__v_199) } else { bytes2_xor_value(__v_55, __v_199, record)? }; + let __v_212: G = if unconstrained { Bytes2::validate_inputs(&__v_56, &__v_200)?; Bytes2::xor(&__v_56, &__v_200) } else { bytes2_xor_value(__v_56, __v_200, record)? }; let __u32_sum: u128 = u128::from(((__v_37.as_canonical_u64() << 0) | (__v_38.as_canonical_u64() << 8) | (__v_39.as_canonical_u64() << 16) | (__v_40.as_canonical_u64() << 24))) + u128::from(((__v_211.as_canonical_u64() << 0) | (__v_212.as_canonical_u64() << 8) | (__v_209.as_canonical_u64() << 16) | (__v_210.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_213: G = G::from_u8(__u32_bytes[0]); @@ -7094,22 +7172,22 @@ fn aiur_fn_76( let __v_215: G = G::from_u8(__u32_bytes[2]); let __v_216: G = G::from_u8(__u32_bytes[3]); let __v_217: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_213; let __vj = __v_214; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_215; let __vj = __v_216; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_213; let __vj = __v_214; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_215; let __vj = __v_216; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_218: G = (__v_217 * __v_217); if (__v_218 != __v_217) { return Err(ExecError::AssertEqMismatch { lhs: __v_218.as_canonical_u64(), rhs: __v_217.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_21, &__v_213)?; Bytes2::xor_split4(&__v_21, &__v_213) } else { bytes2_xor_split4_value(__v_21, __v_213, record)? }; let __v_219: G = __b2_out.0; let __v_220: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_22, &__v_214)?; Bytes2::xor_split4(&__v_22, &__v_214) } else { bytes2_xor_split4_value(__v_22, __v_214, record)? }; let __v_221: G = __b2_out.0; let __v_222: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_23, &__v_215)?; Bytes2::xor_split4(&__v_23, &__v_215) } else { bytes2_xor_split4_value(__v_23, __v_215, record)? }; let __v_223: G = __b2_out.0; let __v_224: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_24, &__v_216)?; Bytes2::xor_split4(&__v_24, &__v_216) } else { bytes2_xor_split4_value(__v_24, __v_216, record)? }; let __v_225: G = __b2_out.0; let __v_226: G = __b2_out.1; let __v_227: G = (__v_221 + __v_224); @@ -7123,8 +7201,8 @@ fn aiur_fn_76( let __v_233: G = G::from_u8(__u32_bytes[2]); let __v_234: G = G::from_u8(__u32_bytes[3]); let __v_235: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_231; let __vj = __v_232; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_233; let __vj = __v_234; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_231; let __vj = __v_232; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_233; let __vj = __v_234; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_236: G = G::from_u64(1); let __v_237: G = (__v_235 - __v_236); let __v_238: G = G::from_u64(2); @@ -7135,10 +7213,10 @@ fn aiur_fn_76( if (__v_241 != __v_242) { return Err(ExecError::AssertEqMismatch { lhs: __v_241.as_canonical_u64(), rhs: __v_242.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_243: G = if unconstrained { Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record) }; - let __v_244: G = if unconstrained { Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record) }; - let __v_245: G = if unconstrained { Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record) }; - let __v_246: G = if unconstrained { Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record) }; + let __v_243: G = if unconstrained { Bytes2::validate_inputs(&__v_211, &__v_231)?; Bytes2::xor(&__v_211, &__v_231) } else { bytes2_xor_value(__v_211, __v_231, record)? }; + let __v_244: G = if unconstrained { Bytes2::validate_inputs(&__v_212, &__v_232)?; Bytes2::xor(&__v_212, &__v_232) } else { bytes2_xor_value(__v_212, __v_232, record)? }; + let __v_245: G = if unconstrained { Bytes2::validate_inputs(&__v_209, &__v_233)?; Bytes2::xor(&__v_209, &__v_233) } else { bytes2_xor_value(__v_209, __v_233, record)? }; + let __v_246: G = if unconstrained { Bytes2::validate_inputs(&__v_210, &__v_234)?; Bytes2::xor(&__v_210, &__v_234) } else { bytes2_xor_value(__v_210, __v_234, record)? }; let __u32_sum: u128 = u128::from(((__v_213.as_canonical_u64() << 0) | (__v_214.as_canonical_u64() << 8) | (__v_215.as_canonical_u64() << 16) | (__v_216.as_canonical_u64() << 24))) + u128::from(((__v_244.as_canonical_u64() << 0) | (__v_245.as_canonical_u64() << 8) | (__v_246.as_canonical_u64() << 16) | (__v_243.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_247: G = G::from_u8(__u32_bytes[0]); @@ -7146,22 +7224,22 @@ fn aiur_fn_76( let __v_249: G = G::from_u8(__u32_bytes[2]); let __v_250: G = G::from_u8(__u32_bytes[3]); let __v_251: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_247; let __vj = __v_248; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_249; let __vj = __v_250; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_247; let __vj = __v_248; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_249; let __vj = __v_250; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_252: G = (__v_251 * __v_251); if (__v_252 != __v_251) { return Err(ExecError::AssertEqMismatch { lhs: __v_252.as_canonical_u64(), rhs: __v_251.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_227, &__v_247)?; Bytes2::xor_split7(&__v_227, &__v_247) } else { bytes2_xor_split7_value(__v_227, __v_247, record)? }; let __v_253: G = __b2_out.0; let __v_254: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_228, &__v_248)?; Bytes2::xor_split7(&__v_228, &__v_248) } else { bytes2_xor_split7_value(__v_228, __v_248, record)? }; let __v_255: G = __b2_out.0; let __v_256: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_229, &__v_249)?; Bytes2::xor_split7(&__v_229, &__v_249) } else { bytes2_xor_split7_value(__v_229, __v_249, record)? }; let __v_257: G = __b2_out.0; let __v_258: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_230, &__v_250)?; Bytes2::xor_split7(&__v_230, &__v_250) } else { bytes2_xor_split7_value(__v_230, __v_250, record)? }; let __v_259: G = __b2_out.0; let __v_260: G = __b2_out.1; let __v_261: G = (__v_253 + __v_256); @@ -7175,8 +7253,8 @@ fn aiur_fn_76( let __v_267: G = G::from_u8(__u32_bytes[2]); let __v_268: G = G::from_u8(__u32_bytes[3]); let __v_269: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_265; let __vj = __v_266; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_267; let __vj = __v_268; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_265; let __vj = __v_266; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_267; let __vj = __v_268; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_270: G = G::from_u64(1); let __v_271: G = (__v_269 - __v_270); let __v_272: G = G::from_u64(2); @@ -7187,10 +7265,10 @@ fn aiur_fn_76( if (__v_275 != __v_276) { return Err(ExecError::AssertEqMismatch { lhs: __v_275.as_canonical_u64(), rhs: __v_276.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_277: G = if unconstrained { Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record) }; - let __v_278: G = if unconstrained { Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record) }; - let __v_279: G = if unconstrained { Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record) }; - let __v_280: G = if unconstrained { Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record) }; + let __v_277: G = if unconstrained { Bytes2::validate_inputs(&__v_57, &__v_265)?; Bytes2::xor(&__v_57, &__v_265) } else { bytes2_xor_value(__v_57, __v_265, record)? }; + let __v_278: G = if unconstrained { Bytes2::validate_inputs(&__v_58, &__v_266)?; Bytes2::xor(&__v_58, &__v_266) } else { bytes2_xor_value(__v_58, __v_266, record)? }; + let __v_279: G = if unconstrained { Bytes2::validate_inputs(&__v_59, &__v_267)?; Bytes2::xor(&__v_59, &__v_267) } else { bytes2_xor_value(__v_59, __v_267, record)? }; + let __v_280: G = if unconstrained { Bytes2::validate_inputs(&__v_60, &__v_268)?; Bytes2::xor(&__v_60, &__v_268) } else { bytes2_xor_value(__v_60, __v_268, record)? }; let __u32_sum: u128 = u128::from(((__v_41.as_canonical_u64() << 0) | (__v_42.as_canonical_u64() << 8) | (__v_43.as_canonical_u64() << 16) | (__v_44.as_canonical_u64() << 24))) + u128::from(((__v_279.as_canonical_u64() << 0) | (__v_280.as_canonical_u64() << 8) | (__v_277.as_canonical_u64() << 16) | (__v_278.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_281: G = G::from_u8(__u32_bytes[0]); @@ -7198,22 +7276,22 @@ fn aiur_fn_76( let __v_283: G = G::from_u8(__u32_bytes[2]); let __v_284: G = G::from_u8(__u32_bytes[3]); let __v_285: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_281; let __vj = __v_282; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_283; let __vj = __v_284; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_281; let __vj = __v_282; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_283; let __vj = __v_284; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_286: G = (__v_285 * __v_285); if (__v_286 != __v_285) { return Err(ExecError::AssertEqMismatch { lhs: __v_286.as_canonical_u64(), rhs: __v_285.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_25, &__v_281)?; Bytes2::xor_split4(&__v_25, &__v_281) } else { bytes2_xor_split4_value(__v_25, __v_281, record)? }; let __v_287: G = __b2_out.0; let __v_288: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_26, &__v_282)?; Bytes2::xor_split4(&__v_26, &__v_282) } else { bytes2_xor_split4_value(__v_26, __v_282, record)? }; let __v_289: G = __b2_out.0; let __v_290: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_27, &__v_283)?; Bytes2::xor_split4(&__v_27, &__v_283) } else { bytes2_xor_split4_value(__v_27, __v_283, record)? }; let __v_291: G = __b2_out.0; let __v_292: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_284)?; Bytes2::xor_split4(&__v_28, &__v_284) } else { bytes2_xor_split4_value(__v_28, __v_284, record)? }; let __v_293: G = __b2_out.0; let __v_294: G = __b2_out.1; let __v_295: G = (__v_289 + __v_292); @@ -7227,8 +7305,8 @@ fn aiur_fn_76( let __v_301: G = G::from_u8(__u32_bytes[2]); let __v_302: G = G::from_u8(__u32_bytes[3]); let __v_303: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_299; let __vj = __v_300; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_301; let __vj = __v_302; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_299; let __vj = __v_300; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_301; let __vj = __v_302; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_304: G = G::from_u64(1); let __v_305: G = (__v_303 - __v_304); let __v_306: G = G::from_u64(2); @@ -7239,10 +7317,10 @@ fn aiur_fn_76( if (__v_309 != __v_310) { return Err(ExecError::AssertEqMismatch { lhs: __v_309.as_canonical_u64(), rhs: __v_310.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_311: G = if unconstrained { Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record) }; - let __v_312: G = if unconstrained { Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record) }; - let __v_313: G = if unconstrained { Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record) }; - let __v_314: G = if unconstrained { Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record) }; + let __v_311: G = if unconstrained { Bytes2::validate_inputs(&__v_279, &__v_299)?; Bytes2::xor(&__v_279, &__v_299) } else { bytes2_xor_value(__v_279, __v_299, record)? }; + let __v_312: G = if unconstrained { Bytes2::validate_inputs(&__v_280, &__v_300)?; Bytes2::xor(&__v_280, &__v_300) } else { bytes2_xor_value(__v_280, __v_300, record)? }; + let __v_313: G = if unconstrained { Bytes2::validate_inputs(&__v_277, &__v_301)?; Bytes2::xor(&__v_277, &__v_301) } else { bytes2_xor_value(__v_277, __v_301, record)? }; + let __v_314: G = if unconstrained { Bytes2::validate_inputs(&__v_278, &__v_302)?; Bytes2::xor(&__v_278, &__v_302) } else { bytes2_xor_value(__v_278, __v_302, record)? }; let __u32_sum: u128 = u128::from(((__v_281.as_canonical_u64() << 0) | (__v_282.as_canonical_u64() << 8) | (__v_283.as_canonical_u64() << 16) | (__v_284.as_canonical_u64() << 24))) + u128::from(((__v_312.as_canonical_u64() << 0) | (__v_313.as_canonical_u64() << 8) | (__v_314.as_canonical_u64() << 16) | (__v_311.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_315: G = G::from_u8(__u32_bytes[0]); @@ -7250,22 +7328,22 @@ fn aiur_fn_76( let __v_317: G = G::from_u8(__u32_bytes[2]); let __v_318: G = G::from_u8(__u32_bytes[3]); let __v_319: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_315; let __vj = __v_316; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_317; let __vj = __v_318; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_315; let __vj = __v_316; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_317; let __vj = __v_318; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_320: G = (__v_319 * __v_319); if (__v_320 != __v_319) { return Err(ExecError::AssertEqMismatch { lhs: __v_320.as_canonical_u64(), rhs: __v_319.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_295, &__v_315)?; Bytes2::xor_split7(&__v_295, &__v_315) } else { bytes2_xor_split7_value(__v_295, __v_315, record)? }; let __v_321: G = __b2_out.0; let __v_322: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_296, &__v_316)?; Bytes2::xor_split7(&__v_296, &__v_316) } else { bytes2_xor_split7_value(__v_296, __v_316, record)? }; let __v_323: G = __b2_out.0; let __v_324: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_297, &__v_317)?; Bytes2::xor_split7(&__v_297, &__v_317) } else { bytes2_xor_split7_value(__v_297, __v_317, record)? }; let __v_325: G = __b2_out.0; let __v_326: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_298, &__v_318)?; Bytes2::xor_split7(&__v_298, &__v_318) } else { bytes2_xor_split7_value(__v_298, __v_318, record)? }; let __v_327: G = __b2_out.0; let __v_328: G = __b2_out.1; let __v_329: G = (__v_321 + __v_324); @@ -7279,8 +7357,8 @@ fn aiur_fn_76( let __v_335: G = G::from_u8(__u32_bytes[2]); let __v_336: G = G::from_u8(__u32_bytes[3]); let __v_337: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_333; let __vj = __v_334; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_335; let __vj = __v_336; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_333; let __vj = __v_334; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_335; let __vj = __v_336; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_338: G = G::from_u64(1); let __v_339: G = (__v_337 - __v_338); let __v_340: G = G::from_u64(2); @@ -7291,10 +7369,10 @@ fn aiur_fn_76( if (__v_343 != __v_344) { return Err(ExecError::AssertEqMismatch { lhs: __v_343.as_canonical_u64(), rhs: __v_344.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_345: G = if unconstrained { Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record) }; - let __v_346: G = if unconstrained { Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record) }; - let __v_347: G = if unconstrained { Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record) }; - let __v_348: G = if unconstrained { Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record) }; + let __v_345: G = if unconstrained { Bytes2::validate_inputs(&__v_61, &__v_333)?; Bytes2::xor(&__v_61, &__v_333) } else { bytes2_xor_value(__v_61, __v_333, record)? }; + let __v_346: G = if unconstrained { Bytes2::validate_inputs(&__v_62, &__v_334)?; Bytes2::xor(&__v_62, &__v_334) } else { bytes2_xor_value(__v_62, __v_334, record)? }; + let __v_347: G = if unconstrained { Bytes2::validate_inputs(&__v_63, &__v_335)?; Bytes2::xor(&__v_63, &__v_335) } else { bytes2_xor_value(__v_63, __v_335, record)? }; + let __v_348: G = if unconstrained { Bytes2::validate_inputs(&__v_64, &__v_336)?; Bytes2::xor(&__v_64, &__v_336) } else { bytes2_xor_value(__v_64, __v_336, record)? }; let __u32_sum: u128 = u128::from(((__v_45.as_canonical_u64() << 0) | (__v_46.as_canonical_u64() << 8) | (__v_47.as_canonical_u64() << 16) | (__v_48.as_canonical_u64() << 24))) + u128::from(((__v_347.as_canonical_u64() << 0) | (__v_348.as_canonical_u64() << 8) | (__v_345.as_canonical_u64() << 16) | (__v_346.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_349: G = G::from_u8(__u32_bytes[0]); @@ -7302,22 +7380,22 @@ fn aiur_fn_76( let __v_351: G = G::from_u8(__u32_bytes[2]); let __v_352: G = G::from_u8(__u32_bytes[3]); let __v_353: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_349; let __vj = __v_350; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_351; let __vj = __v_352; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_349; let __vj = __v_350; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_351; let __vj = __v_352; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_354: G = (__v_353 * __v_353); if (__v_354 != __v_353) { return Err(ExecError::AssertEqMismatch { lhs: __v_354.as_canonical_u64(), rhs: __v_353.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_29, &__v_349)?; Bytes2::xor_split4(&__v_29, &__v_349) } else { bytes2_xor_split4_value(__v_29, __v_349, record)? }; let __v_355: G = __b2_out.0; let __v_356: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_30, &__v_350)?; Bytes2::xor_split4(&__v_30, &__v_350) } else { bytes2_xor_split4_value(__v_30, __v_350, record)? }; let __v_357: G = __b2_out.0; let __v_358: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_31, &__v_351)?; Bytes2::xor_split4(&__v_31, &__v_351) } else { bytes2_xor_split4_value(__v_31, __v_351, record)? }; let __v_359: G = __b2_out.0; let __v_360: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_32, &__v_352)?; Bytes2::xor_split4(&__v_32, &__v_352) } else { bytes2_xor_split4_value(__v_32, __v_352, record)? }; let __v_361: G = __b2_out.0; let __v_362: G = __b2_out.1; let __v_363: G = (__v_357 + __v_360); @@ -7331,8 +7409,8 @@ fn aiur_fn_76( let __v_369: G = G::from_u8(__u32_bytes[2]); let __v_370: G = G::from_u8(__u32_bytes[3]); let __v_371: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_367; let __vj = __v_368; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_369; let __vj = __v_370; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_367; let __vj = __v_368; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_369; let __vj = __v_370; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_372: G = G::from_u64(1); let __v_373: G = (__v_371 - __v_372); let __v_374: G = G::from_u64(2); @@ -7343,10 +7421,10 @@ fn aiur_fn_76( if (__v_377 != __v_378) { return Err(ExecError::AssertEqMismatch { lhs: __v_377.as_canonical_u64(), rhs: __v_378.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_379: G = if unconstrained { Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record) }; - let __v_380: G = if unconstrained { Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record) }; - let __v_381: G = if unconstrained { Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record) }; - let __v_382: G = if unconstrained { Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record) }; + let __v_379: G = if unconstrained { Bytes2::validate_inputs(&__v_347, &__v_367)?; Bytes2::xor(&__v_347, &__v_367) } else { bytes2_xor_value(__v_347, __v_367, record)? }; + let __v_380: G = if unconstrained { Bytes2::validate_inputs(&__v_348, &__v_368)?; Bytes2::xor(&__v_348, &__v_368) } else { bytes2_xor_value(__v_348, __v_368, record)? }; + let __v_381: G = if unconstrained { Bytes2::validate_inputs(&__v_345, &__v_369)?; Bytes2::xor(&__v_345, &__v_369) } else { bytes2_xor_value(__v_345, __v_369, record)? }; + let __v_382: G = if unconstrained { Bytes2::validate_inputs(&__v_346, &__v_370)?; Bytes2::xor(&__v_346, &__v_370) } else { bytes2_xor_value(__v_346, __v_370, record)? }; let __u32_sum: u128 = u128::from(((__v_349.as_canonical_u64() << 0) | (__v_350.as_canonical_u64() << 8) | (__v_351.as_canonical_u64() << 16) | (__v_352.as_canonical_u64() << 24))) + u128::from(((__v_380.as_canonical_u64() << 0) | (__v_381.as_canonical_u64() << 8) | (__v_382.as_canonical_u64() << 16) | (__v_379.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_383: G = G::from_u8(__u32_bytes[0]); @@ -7354,22 +7432,22 @@ fn aiur_fn_76( let __v_385: G = G::from_u8(__u32_bytes[2]); let __v_386: G = G::from_u8(__u32_bytes[3]); let __v_387: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_383; let __vj = __v_384; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_385; let __vj = __v_386; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_383; let __vj = __v_384; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_385; let __vj = __v_386; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_388: G = (__v_387 * __v_387); if (__v_388 != __v_387) { return Err(ExecError::AssertEqMismatch { lhs: __v_388.as_canonical_u64(), rhs: __v_387.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_363, &__v_383)?; Bytes2::xor_split7(&__v_363, &__v_383) } else { bytes2_xor_split7_value(__v_363, __v_383, record)? }; let __v_389: G = __b2_out.0; let __v_390: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_364, &__v_384)?; Bytes2::xor_split7(&__v_364, &__v_384) } else { bytes2_xor_split7_value(__v_364, __v_384, record)? }; let __v_391: G = __b2_out.0; let __v_392: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_365, &__v_385)?; Bytes2::xor_split7(&__v_365, &__v_385) } else { bytes2_xor_split7_value(__v_365, __v_385, record)? }; let __v_393: G = __b2_out.0; let __v_394: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_366, &__v_386)?; Bytes2::xor_split7(&__v_366, &__v_386) } else { bytes2_xor_split7_value(__v_366, __v_386, record)? }; let __v_395: G = __b2_out.0; let __v_396: G = __b2_out.1; let __v_397: G = (__v_389 + __v_392); @@ -7383,8 +7461,8 @@ fn aiur_fn_76( let __v_403: G = G::from_u8(__u32_bytes[2]); let __v_404: G = G::from_u8(__u32_bytes[3]); let __v_405: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_401; let __vj = __v_402; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_403; let __vj = __v_404; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_401; let __vj = __v_402; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_403; let __vj = __v_404; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_406: G = G::from_u64(1); let __v_407: G = (__v_405 - __v_406); let __v_408: G = G::from_u64(2); @@ -7395,10 +7473,10 @@ fn aiur_fn_76( if (__v_411 != __v_412) { return Err(ExecError::AssertEqMismatch { lhs: __v_411.as_canonical_u64(), rhs: __v_412.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_413: G = if unconstrained { Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record) }; - let __v_414: G = if unconstrained { Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record) }; - let __v_415: G = if unconstrained { Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record) }; - let __v_416: G = if unconstrained { Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record) }; + let __v_413: G = if unconstrained { Bytes2::validate_inputs(&__v_380, &__v_401)?; Bytes2::xor(&__v_380, &__v_401) } else { bytes2_xor_value(__v_380, __v_401, record)? }; + let __v_414: G = if unconstrained { Bytes2::validate_inputs(&__v_381, &__v_402)?; Bytes2::xor(&__v_381, &__v_402) } else { bytes2_xor_value(__v_381, __v_402, record)? }; + let __v_415: G = if unconstrained { Bytes2::validate_inputs(&__v_382, &__v_403)?; Bytes2::xor(&__v_382, &__v_403) } else { bytes2_xor_value(__v_382, __v_403, record)? }; + let __v_416: G = if unconstrained { Bytes2::validate_inputs(&__v_379, &__v_404)?; Bytes2::xor(&__v_379, &__v_404) } else { bytes2_xor_value(__v_379, __v_404, record)? }; let __u32_sum: u128 = u128::from(((__v_315.as_canonical_u64() << 0) | (__v_316.as_canonical_u64() << 8) | (__v_317.as_canonical_u64() << 16) | (__v_318.as_canonical_u64() << 24))) + u128::from(((__v_415.as_canonical_u64() << 0) | (__v_416.as_canonical_u64() << 8) | (__v_413.as_canonical_u64() << 16) | (__v_414.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_417: G = G::from_u8(__u32_bytes[0]); @@ -7406,22 +7484,22 @@ fn aiur_fn_76( let __v_419: G = G::from_u8(__u32_bytes[2]); let __v_420: G = G::from_u8(__u32_bytes[3]); let __v_421: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_417; let __vj = __v_418; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_419; let __vj = __v_420; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_417; let __vj = __v_418; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_419; let __vj = __v_420; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_422: G = (__v_421 * __v_421); if (__v_422 != __v_421) { return Err(ExecError::AssertEqMismatch { lhs: __v_422.as_canonical_u64(), rhs: __v_421.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_261, &__v_417)?; Bytes2::xor_split4(&__v_261, &__v_417) } else { bytes2_xor_split4_value(__v_261, __v_417, record)? }; let __v_423: G = __b2_out.0; let __v_424: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_262, &__v_418)?; Bytes2::xor_split4(&__v_262, &__v_418) } else { bytes2_xor_split4_value(__v_262, __v_418, record)? }; let __v_425: G = __b2_out.0; let __v_426: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_263, &__v_419)?; Bytes2::xor_split4(&__v_263, &__v_419) } else { bytes2_xor_split4_value(__v_263, __v_419, record)? }; let __v_427: G = __b2_out.0; let __v_428: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_264, &__v_420)?; Bytes2::xor_split4(&__v_264, &__v_420) } else { bytes2_xor_split4_value(__v_264, __v_420, record)? }; let __v_429: G = __b2_out.0; let __v_430: G = __b2_out.1; let __v_431: G = (__v_425 + __v_428); @@ -7435,8 +7513,8 @@ fn aiur_fn_76( let __v_437: G = G::from_u8(__u32_bytes[2]); let __v_438: G = G::from_u8(__u32_bytes[3]); let __v_439: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_435; let __vj = __v_436; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_437; let __vj = __v_438; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_435; let __vj = __v_436; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_437; let __vj = __v_438; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_440: G = G::from_u64(1); let __v_441: G = (__v_439 - __v_440); let __v_442: G = G::from_u64(2); @@ -7447,10 +7525,10 @@ fn aiur_fn_76( if (__v_445 != __v_446) { return Err(ExecError::AssertEqMismatch { lhs: __v_445.as_canonical_u64(), rhs: __v_446.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_447: G = if unconstrained { Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record) }; - let __v_448: G = if unconstrained { Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record) }; - let __v_449: G = if unconstrained { Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record) }; - let __v_450: G = if unconstrained { Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record) }; + let __v_447: G = if unconstrained { Bytes2::validate_inputs(&__v_415, &__v_435)?; Bytes2::xor(&__v_415, &__v_435) } else { bytes2_xor_value(__v_415, __v_435, record)? }; + let __v_448: G = if unconstrained { Bytes2::validate_inputs(&__v_416, &__v_436)?; Bytes2::xor(&__v_416, &__v_436) } else { bytes2_xor_value(__v_416, __v_436, record)? }; + let __v_449: G = if unconstrained { Bytes2::validate_inputs(&__v_413, &__v_437)?; Bytes2::xor(&__v_413, &__v_437) } else { bytes2_xor_value(__v_413, __v_437, record)? }; + let __v_450: G = if unconstrained { Bytes2::validate_inputs(&__v_414, &__v_438)?; Bytes2::xor(&__v_414, &__v_438) } else { bytes2_xor_value(__v_414, __v_438, record)? }; let __u32_sum: u128 = u128::from(((__v_417.as_canonical_u64() << 0) | (__v_418.as_canonical_u64() << 8) | (__v_419.as_canonical_u64() << 16) | (__v_420.as_canonical_u64() << 24))) + u128::from(((__v_448.as_canonical_u64() << 0) | (__v_449.as_canonical_u64() << 8) | (__v_450.as_canonical_u64() << 16) | (__v_447.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_451: G = G::from_u8(__u32_bytes[0]); @@ -7458,22 +7536,22 @@ fn aiur_fn_76( let __v_453: G = G::from_u8(__u32_bytes[2]); let __v_454: G = G::from_u8(__u32_bytes[3]); let __v_455: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_451; let __vj = __v_452; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_453; let __vj = __v_454; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_451; let __vj = __v_452; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_453; let __vj = __v_454; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_456: G = (__v_455 * __v_455); if (__v_456 != __v_455) { return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_431, &__v_451)?; Bytes2::xor_split7(&__v_431, &__v_451) } else { bytes2_xor_split7_value(__v_431, __v_451, record)? }; let __v_457: G = __b2_out.0; let __v_458: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_432, &__v_452)?; Bytes2::xor_split7(&__v_432, &__v_452) } else { bytes2_xor_split7_value(__v_432, __v_452, record)? }; let __v_459: G = __b2_out.0; let __v_460: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_433, &__v_453)?; Bytes2::xor_split7(&__v_433, &__v_453) } else { bytes2_xor_split7_value(__v_433, __v_453, record)? }; let __v_461: G = __b2_out.0; let __v_462: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_434, &__v_454)?; Bytes2::xor_split7(&__v_434, &__v_454) } else { bytes2_xor_split7_value(__v_434, __v_454, record)? }; let __v_463: G = __b2_out.0; let __v_464: G = __b2_out.1; let __v_465: G = (__v_457 + __v_460); @@ -7487,8 +7565,8 @@ fn aiur_fn_76( let __v_471: G = G::from_u8(__u32_bytes[2]); let __v_472: G = G::from_u8(__u32_bytes[3]); let __v_473: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_469; let __vj = __v_470; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_471; let __vj = __v_472; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_469; let __vj = __v_470; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_471; let __vj = __v_472; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_474: G = G::from_u64(1); let __v_475: G = (__v_473 - __v_474); let __v_476: G = G::from_u64(2); @@ -7499,10 +7577,10 @@ fn aiur_fn_76( if (__v_479 != __v_480) { return Err(ExecError::AssertEqMismatch { lhs: __v_479.as_canonical_u64(), rhs: __v_480.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_481: G = if unconstrained { Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record) }; - let __v_482: G = if unconstrained { Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record) }; - let __v_483: G = if unconstrained { Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record) }; - let __v_484: G = if unconstrained { Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record) }; + let __v_481: G = if unconstrained { Bytes2::validate_inputs(&__v_176, &__v_469)?; Bytes2::xor(&__v_176, &__v_469) } else { bytes2_xor_value(__v_176, __v_469, record)? }; + let __v_482: G = if unconstrained { Bytes2::validate_inputs(&__v_177, &__v_470)?; Bytes2::xor(&__v_177, &__v_470) } else { bytes2_xor_value(__v_177, __v_470, record)? }; + let __v_483: G = if unconstrained { Bytes2::validate_inputs(&__v_178, &__v_471)?; Bytes2::xor(&__v_178, &__v_471) } else { bytes2_xor_value(__v_178, __v_471, record)? }; + let __v_484: G = if unconstrained { Bytes2::validate_inputs(&__v_175, &__v_472)?; Bytes2::xor(&__v_175, &__v_472) } else { bytes2_xor_value(__v_175, __v_472, record)? }; let __u32_sum: u128 = u128::from(((__v_383.as_canonical_u64() << 0) | (__v_384.as_canonical_u64() << 8) | (__v_385.as_canonical_u64() << 16) | (__v_386.as_canonical_u64() << 24))) + u128::from(((__v_483.as_canonical_u64() << 0) | (__v_484.as_canonical_u64() << 8) | (__v_481.as_canonical_u64() << 16) | (__v_482.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_485: G = G::from_u8(__u32_bytes[0]); @@ -7510,22 +7588,22 @@ fn aiur_fn_76( let __v_487: G = G::from_u8(__u32_bytes[2]); let __v_488: G = G::from_u8(__u32_bytes[3]); let __v_489: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_485; let __vj = __v_486; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_487; let __vj = __v_488; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_485; let __vj = __v_486; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_487; let __vj = __v_488; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_490: G = (__v_489 * __v_489); if (__v_490 != __v_489) { return Err(ExecError::AssertEqMismatch { lhs: __v_490.as_canonical_u64(), rhs: __v_489.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_329, &__v_485)?; Bytes2::xor_split4(&__v_329, &__v_485) } else { bytes2_xor_split4_value(__v_329, __v_485, record)? }; let __v_491: G = __b2_out.0; let __v_492: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_330, &__v_486)?; Bytes2::xor_split4(&__v_330, &__v_486) } else { bytes2_xor_split4_value(__v_330, __v_486, record)? }; let __v_493: G = __b2_out.0; let __v_494: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_331, &__v_487)?; Bytes2::xor_split4(&__v_331, &__v_487) } else { bytes2_xor_split4_value(__v_331, __v_487, record)? }; let __v_495: G = __b2_out.0; let __v_496: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_332, &__v_488)?; Bytes2::xor_split4(&__v_332, &__v_488) } else { bytes2_xor_split4_value(__v_332, __v_488, record)? }; let __v_497: G = __b2_out.0; let __v_498: G = __b2_out.1; let __v_499: G = (__v_493 + __v_496); @@ -7539,8 +7617,8 @@ fn aiur_fn_76( let __v_505: G = G::from_u8(__u32_bytes[2]); let __v_506: G = G::from_u8(__u32_bytes[3]); let __v_507: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_503; let __vj = __v_504; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_505; let __vj = __v_506; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_503; let __vj = __v_504; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_505; let __vj = __v_506; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_508: G = G::from_u64(1); let __v_509: G = (__v_507 - __v_508); let __v_510: G = G::from_u64(2); @@ -7551,10 +7629,10 @@ fn aiur_fn_76( if (__v_513 != __v_514) { return Err(ExecError::AssertEqMismatch { lhs: __v_513.as_canonical_u64(), rhs: __v_514.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_515: G = if unconstrained { Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record) }; - let __v_516: G = if unconstrained { Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record) }; - let __v_517: G = if unconstrained { Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record) }; - let __v_518: G = if unconstrained { Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record) }; + let __v_515: G = if unconstrained { Bytes2::validate_inputs(&__v_483, &__v_503)?; Bytes2::xor(&__v_483, &__v_503) } else { bytes2_xor_value(__v_483, __v_503, record)? }; + let __v_516: G = if unconstrained { Bytes2::validate_inputs(&__v_484, &__v_504)?; Bytes2::xor(&__v_484, &__v_504) } else { bytes2_xor_value(__v_484, __v_504, record)? }; + let __v_517: G = if unconstrained { Bytes2::validate_inputs(&__v_481, &__v_505)?; Bytes2::xor(&__v_481, &__v_505) } else { bytes2_xor_value(__v_481, __v_505, record)? }; + let __v_518: G = if unconstrained { Bytes2::validate_inputs(&__v_482, &__v_506)?; Bytes2::xor(&__v_482, &__v_506) } else { bytes2_xor_value(__v_482, __v_506, record)? }; let __u32_sum: u128 = u128::from(((__v_485.as_canonical_u64() << 0) | (__v_486.as_canonical_u64() << 8) | (__v_487.as_canonical_u64() << 16) | (__v_488.as_canonical_u64() << 24))) + u128::from(((__v_516.as_canonical_u64() << 0) | (__v_517.as_canonical_u64() << 8) | (__v_518.as_canonical_u64() << 16) | (__v_515.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_519: G = G::from_u8(__u32_bytes[0]); @@ -7562,22 +7640,22 @@ fn aiur_fn_76( let __v_521: G = G::from_u8(__u32_bytes[2]); let __v_522: G = G::from_u8(__u32_bytes[3]); let __v_523: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_519; let __vj = __v_520; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_521; let __vj = __v_522; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_519; let __vj = __v_520; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_521; let __vj = __v_522; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_524: G = (__v_523 * __v_523); if (__v_524 != __v_523) { return Err(ExecError::AssertEqMismatch { lhs: __v_524.as_canonical_u64(), rhs: __v_523.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_499, &__v_519)?; Bytes2::xor_split7(&__v_499, &__v_519) } else { bytes2_xor_split7_value(__v_499, __v_519, record)? }; let __v_525: G = __b2_out.0; let __v_526: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_500, &__v_520)?; Bytes2::xor_split7(&__v_500, &__v_520) } else { bytes2_xor_split7_value(__v_500, __v_520, record)? }; let __v_527: G = __b2_out.0; let __v_528: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_501, &__v_521)?; Bytes2::xor_split7(&__v_501, &__v_521) } else { bytes2_xor_split7_value(__v_501, __v_521, record)? }; let __v_529: G = __b2_out.0; let __v_530: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_502, &__v_522)?; Bytes2::xor_split7(&__v_502, &__v_522) } else { bytes2_xor_split7_value(__v_502, __v_522, record)? }; let __v_531: G = __b2_out.0; let __v_532: G = __b2_out.1; let __v_533: G = (__v_525 + __v_528); @@ -7591,8 +7669,8 @@ fn aiur_fn_76( let __v_539: G = G::from_u8(__u32_bytes[2]); let __v_540: G = G::from_u8(__u32_bytes[3]); let __v_541: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_537; let __vj = __v_538; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_539; let __vj = __v_540; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_537; let __vj = __v_538; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_539; let __vj = __v_540; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_542: G = G::from_u64(1); let __v_543: G = (__v_541 - __v_542); let __v_544: G = G::from_u64(2); @@ -7603,10 +7681,10 @@ fn aiur_fn_76( if (__v_547 != __v_548) { return Err(ExecError::AssertEqMismatch { lhs: __v_547.as_canonical_u64(), rhs: __v_548.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_549: G = if unconstrained { Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record) }; - let __v_550: G = if unconstrained { Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record) }; - let __v_551: G = if unconstrained { Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record) }; - let __v_552: G = if unconstrained { Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record) }; + let __v_549: G = if unconstrained { Bytes2::validate_inputs(&__v_244, &__v_537)?; Bytes2::xor(&__v_244, &__v_537) } else { bytes2_xor_value(__v_244, __v_537, record)? }; + let __v_550: G = if unconstrained { Bytes2::validate_inputs(&__v_245, &__v_538)?; Bytes2::xor(&__v_245, &__v_538) } else { bytes2_xor_value(__v_245, __v_538, record)? }; + let __v_551: G = if unconstrained { Bytes2::validate_inputs(&__v_246, &__v_539)?; Bytes2::xor(&__v_246, &__v_539) } else { bytes2_xor_value(__v_246, __v_539, record)? }; + let __v_552: G = if unconstrained { Bytes2::validate_inputs(&__v_243, &__v_540)?; Bytes2::xor(&__v_243, &__v_540) } else { bytes2_xor_value(__v_243, __v_540, record)? }; let __u32_sum: u128 = u128::from(((__v_179.as_canonical_u64() << 0) | (__v_180.as_canonical_u64() << 8) | (__v_181.as_canonical_u64() << 16) | (__v_182.as_canonical_u64() << 24))) + u128::from(((__v_551.as_canonical_u64() << 0) | (__v_552.as_canonical_u64() << 8) | (__v_549.as_canonical_u64() << 16) | (__v_550.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_553: G = G::from_u8(__u32_bytes[0]); @@ -7614,22 +7692,22 @@ fn aiur_fn_76( let __v_555: G = G::from_u8(__u32_bytes[2]); let __v_556: G = G::from_u8(__u32_bytes[3]); let __v_557: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_553; let __vj = __v_554; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_555; let __vj = __v_556; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_553; let __vj = __v_554; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_555; let __vj = __v_556; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_558: G = (__v_557 * __v_557); if (__v_558 != __v_557) { return Err(ExecError::AssertEqMismatch { lhs: __v_558.as_canonical_u64(), rhs: __v_557.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_397, &__v_553)?; Bytes2::xor_split4(&__v_397, &__v_553) } else { bytes2_xor_split4_value(__v_397, __v_553, record)? }; let __v_559: G = __b2_out.0; let __v_560: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_398, &__v_554)?; Bytes2::xor_split4(&__v_398, &__v_554) } else { bytes2_xor_split4_value(__v_398, __v_554, record)? }; let __v_561: G = __b2_out.0; let __v_562: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_399, &__v_555)?; Bytes2::xor_split4(&__v_399, &__v_555) } else { bytes2_xor_split4_value(__v_399, __v_555, record)? }; let __v_563: G = __b2_out.0; let __v_564: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_400, &__v_556)?; Bytes2::xor_split4(&__v_400, &__v_556) } else { bytes2_xor_split4_value(__v_400, __v_556, record)? }; let __v_565: G = __b2_out.0; let __v_566: G = __b2_out.1; let __v_567: G = (__v_561 + __v_564); @@ -7643,8 +7721,8 @@ fn aiur_fn_76( let __v_573: G = G::from_u8(__u32_bytes[2]); let __v_574: G = G::from_u8(__u32_bytes[3]); let __v_575: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_571; let __vj = __v_572; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_573; let __vj = __v_574; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_571; let __vj = __v_572; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_573; let __vj = __v_574; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_576: G = G::from_u64(1); let __v_577: G = (__v_575 - __v_576); let __v_578: G = G::from_u64(2); @@ -7655,10 +7733,10 @@ fn aiur_fn_76( if (__v_581 != __v_582) { return Err(ExecError::AssertEqMismatch { lhs: __v_581.as_canonical_u64(), rhs: __v_582.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_583: G = if unconstrained { Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record) }; - let __v_584: G = if unconstrained { Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record) }; - let __v_585: G = if unconstrained { Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record) }; - let __v_586: G = if unconstrained { Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record) }; + let __v_583: G = if unconstrained { Bytes2::validate_inputs(&__v_551, &__v_571)?; Bytes2::xor(&__v_551, &__v_571) } else { bytes2_xor_value(__v_551, __v_571, record)? }; + let __v_584: G = if unconstrained { Bytes2::validate_inputs(&__v_552, &__v_572)?; Bytes2::xor(&__v_552, &__v_572) } else { bytes2_xor_value(__v_552, __v_572, record)? }; + let __v_585: G = if unconstrained { Bytes2::validate_inputs(&__v_549, &__v_573)?; Bytes2::xor(&__v_549, &__v_573) } else { bytes2_xor_value(__v_549, __v_573, record)? }; + let __v_586: G = if unconstrained { Bytes2::validate_inputs(&__v_550, &__v_574)?; Bytes2::xor(&__v_550, &__v_574) } else { bytes2_xor_value(__v_550, __v_574, record)? }; let __u32_sum: u128 = u128::from(((__v_553.as_canonical_u64() << 0) | (__v_554.as_canonical_u64() << 8) | (__v_555.as_canonical_u64() << 16) | (__v_556.as_canonical_u64() << 24))) + u128::from(((__v_584.as_canonical_u64() << 0) | (__v_585.as_canonical_u64() << 8) | (__v_586.as_canonical_u64() << 16) | (__v_583.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_587: G = G::from_u8(__u32_bytes[0]); @@ -7666,22 +7744,22 @@ fn aiur_fn_76( let __v_589: G = G::from_u8(__u32_bytes[2]); let __v_590: G = G::from_u8(__u32_bytes[3]); let __v_591: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_587; let __vj = __v_588; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_589; let __vj = __v_590; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_587; let __vj = __v_588; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_589; let __vj = __v_590; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_592: G = (__v_591 * __v_591); if (__v_592 != __v_591) { return Err(ExecError::AssertEqMismatch { lhs: __v_592.as_canonical_u64(), rhs: __v_591.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_567, &__v_587)?; Bytes2::xor_split7(&__v_567, &__v_587) } else { bytes2_xor_split7_value(__v_567, __v_587, record)? }; let __v_593: G = __b2_out.0; let __v_594: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_568, &__v_588)?; Bytes2::xor_split7(&__v_568, &__v_588) } else { bytes2_xor_split7_value(__v_568, __v_588, record)? }; let __v_595: G = __b2_out.0; let __v_596: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_569, &__v_589)?; Bytes2::xor_split7(&__v_569, &__v_589) } else { bytes2_xor_split7_value(__v_569, __v_589, record)? }; let __v_597: G = __b2_out.0; let __v_598: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_570, &__v_590)?; Bytes2::xor_split7(&__v_570, &__v_590) } else { bytes2_xor_split7_value(__v_570, __v_590, record)? }; let __v_599: G = __b2_out.0; let __v_600: G = __b2_out.1; let __v_601: G = (__v_593 + __v_596); @@ -7695,8 +7773,8 @@ fn aiur_fn_76( let __v_607: G = G::from_u8(__u32_bytes[2]); let __v_608: G = G::from_u8(__u32_bytes[3]); let __v_609: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_605; let __vj = __v_606; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_607; let __vj = __v_608; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_605; let __vj = __v_606; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_607; let __vj = __v_608; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_610: G = G::from_u64(1); let __v_611: G = (__v_609 - __v_610); let __v_612: G = G::from_u64(2); @@ -7707,10 +7785,10 @@ fn aiur_fn_76( if (__v_615 != __v_616) { return Err(ExecError::AssertEqMismatch { lhs: __v_615.as_canonical_u64(), rhs: __v_616.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_617: G = if unconstrained { Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record) }; - let __v_618: G = if unconstrained { Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record) }; - let __v_619: G = if unconstrained { Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record) }; - let __v_620: G = if unconstrained { Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record) }; + let __v_617: G = if unconstrained { Bytes2::validate_inputs(&__v_312, &__v_605)?; Bytes2::xor(&__v_312, &__v_605) } else { bytes2_xor_value(__v_312, __v_605, record)? }; + let __v_618: G = if unconstrained { Bytes2::validate_inputs(&__v_313, &__v_606)?; Bytes2::xor(&__v_313, &__v_606) } else { bytes2_xor_value(__v_313, __v_606, record)? }; + let __v_619: G = if unconstrained { Bytes2::validate_inputs(&__v_314, &__v_607)?; Bytes2::xor(&__v_314, &__v_607) } else { bytes2_xor_value(__v_314, __v_607, record)? }; + let __v_620: G = if unconstrained { Bytes2::validate_inputs(&__v_311, &__v_608)?; Bytes2::xor(&__v_311, &__v_608) } else { bytes2_xor_value(__v_311, __v_608, record)? }; let __u32_sum: u128 = u128::from(((__v_247.as_canonical_u64() << 0) | (__v_248.as_canonical_u64() << 8) | (__v_249.as_canonical_u64() << 16) | (__v_250.as_canonical_u64() << 24))) + u128::from(((__v_619.as_canonical_u64() << 0) | (__v_620.as_canonical_u64() << 8) | (__v_617.as_canonical_u64() << 16) | (__v_618.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_621: G = G::from_u8(__u32_bytes[0]); @@ -7718,22 +7796,22 @@ fn aiur_fn_76( let __v_623: G = G::from_u8(__u32_bytes[2]); let __v_624: G = G::from_u8(__u32_bytes[3]); let __v_625: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_621; let __vj = __v_622; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_623; let __vj = __v_624; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_621; let __vj = __v_622; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_623; let __vj = __v_624; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_626: G = (__v_625 * __v_625); if (__v_626 != __v_625) { return Err(ExecError::AssertEqMismatch { lhs: __v_626.as_canonical_u64(), rhs: __v_625.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_193, &__v_621)?; Bytes2::xor_split4(&__v_193, &__v_621) } else { bytes2_xor_split4_value(__v_193, __v_621, record)? }; let __v_627: G = __b2_out.0; let __v_628: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_194, &__v_622)?; Bytes2::xor_split4(&__v_194, &__v_622) } else { bytes2_xor_split4_value(__v_194, __v_622, record)? }; let __v_629: G = __b2_out.0; let __v_630: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_195, &__v_623)?; Bytes2::xor_split4(&__v_195, &__v_623) } else { bytes2_xor_split4_value(__v_195, __v_623, record)? }; let __v_631: G = __b2_out.0; let __v_632: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_196, &__v_624)?; Bytes2::xor_split4(&__v_196, &__v_624) } else { bytes2_xor_split4_value(__v_196, __v_624, record)? }; let __v_633: G = __b2_out.0; let __v_634: G = __b2_out.1; let __v_635: G = (__v_629 + __v_632); @@ -7747,8 +7825,8 @@ fn aiur_fn_76( let __v_641: G = G::from_u8(__u32_bytes[2]); let __v_642: G = G::from_u8(__u32_bytes[3]); let __v_643: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_639; let __vj = __v_640; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_641; let __vj = __v_642; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_639; let __vj = __v_640; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_641; let __vj = __v_642; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_644: G = G::from_u64(1); let __v_645: G = (__v_643 - __v_644); let __v_646: G = G::from_u64(2); @@ -7759,10 +7837,10 @@ fn aiur_fn_76( if (__v_649 != __v_650) { return Err(ExecError::AssertEqMismatch { lhs: __v_649.as_canonical_u64(), rhs: __v_650.as_canonical_u64(), msg: Some("u32_add3: carry is not in {0, 1, 2}".to_string()) }); } - let __v_651: G = if unconstrained { Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record) }; - let __v_652: G = if unconstrained { Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record) }; - let __v_653: G = if unconstrained { Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record) }; - let __v_654: G = if unconstrained { Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record) }; + let __v_651: G = if unconstrained { Bytes2::validate_inputs(&__v_619, &__v_639)?; Bytes2::xor(&__v_619, &__v_639) } else { bytes2_xor_value(__v_619, __v_639, record)? }; + let __v_652: G = if unconstrained { Bytes2::validate_inputs(&__v_620, &__v_640)?; Bytes2::xor(&__v_620, &__v_640) } else { bytes2_xor_value(__v_620, __v_640, record)? }; + let __v_653: G = if unconstrained { Bytes2::validate_inputs(&__v_617, &__v_641)?; Bytes2::xor(&__v_617, &__v_641) } else { bytes2_xor_value(__v_617, __v_641, record)? }; + let __v_654: G = if unconstrained { Bytes2::validate_inputs(&__v_618, &__v_642)?; Bytes2::xor(&__v_618, &__v_642) } else { bytes2_xor_value(__v_618, __v_642, record)? }; let __u32_sum: u128 = u128::from(((__v_621.as_canonical_u64() << 0) | (__v_622.as_canonical_u64() << 8) | (__v_623.as_canonical_u64() << 16) | (__v_624.as_canonical_u64() << 24))) + u128::from(((__v_652.as_canonical_u64() << 0) | (__v_653.as_canonical_u64() << 8) | (__v_654.as_canonical_u64() << 16) | (__v_651.as_canonical_u64() << 24))); let __u32_bytes = u32::try_from(__u32_sum & 0xFFFF_FFFF).expect("masked").to_le_bytes(); let __v_655: G = G::from_u8(__u32_bytes[0]); @@ -7770,22 +7848,22 @@ fn aiur_fn_76( let __v_657: G = G::from_u8(__u32_bytes[2]); let __v_658: G = G::from_u8(__u32_bytes[3]); let __v_659: G = G::from_u64(u64::try_from(__u32_sum >> 32).expect("u32 sum overflow fits u64")); - if !unconstrained { let __vi = __v_655; let __vj = __v_656; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_657; let __vj = __v_658; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_655; let __vj = __v_656; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_657; let __vj = __v_658; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_660: G = (__v_659 * __v_659); if (__v_660 != __v_659) { return Err(ExecError::AssertEqMismatch { lhs: __v_660.as_canonical_u64(), rhs: __v_659.as_canonical_u64(), msg: Some("u32_add: carry is not boolean".to_string()) }); } - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_635, &__v_655)?; Bytes2::xor_split7(&__v_635, &__v_655) } else { bytes2_xor_split7_value(__v_635, __v_655, record)? }; let __v_661: G = __b2_out.0; let __v_662: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_636, &__v_656)?; Bytes2::xor_split7(&__v_636, &__v_656) } else { bytes2_xor_split7_value(__v_636, __v_656, record)? }; let __v_663: G = __b2_out.0; let __v_664: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_637, &__v_657)?; Bytes2::xor_split7(&__v_637, &__v_657) } else { bytes2_xor_split7_value(__v_637, __v_657, record)? }; let __v_665: G = __b2_out.0; let __v_666: G = __b2_out.1; - let __b2_out: (G, G) = if unconstrained { Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record) }; + let __b2_out: (G, G) = if unconstrained { Bytes2::validate_inputs(&__v_638, &__v_658)?; Bytes2::xor_split7(&__v_638, &__v_658) } else { bytes2_xor_split7_value(__v_638, __v_658, record)? }; let __v_667: G = __b2_out.0; let __v_668: G = __b2_out.1; let __v_669: G = (__v_661 + __v_664); @@ -7794,7 +7872,7 @@ fn aiur_fn_76( let __v_672: G = (__v_667 + __v_662); let __v_673: G = G::from_u64(1); let __v_674: G = (__v_0 + __v_673); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_674, __v_435, __v_436, __v_437, __v_438, __v_503, __v_504, __v_505, __v_506, __v_571, __v_572, __v_573, __v_574, __v_639, __v_640, __v_641, __v_642, __v_669, __v_670, __v_671, __v_672, __v_465, __v_466, __v_467, __v_468, __v_533, __v_534, __v_535, __v_536, __v_601, __v_602, __v_603, __v_604, __v_587, __v_588, __v_589, __v_590, __v_655, __v_656, __v_657, __v_658, __v_451, __v_452, __v_453, __v_454, __v_519, __v_520, __v_521, __v_522, __v_516, __v_517, __v_518, __v_515, __v_584, __v_585, __v_586, __v_583, __v_652, __v_653, __v_654, __v_651, __v_448, __v_449, __v_450, __v_447, __v_73, __v_74, __v_75, __v_76, __v_89, __v_90, __v_91, __v_92, __v_77, __v_78, __v_79, __v_80, __v_105, __v_106, __v_107, __v_108, __v_93, __v_94, __v_95, __v_96, __v_65, __v_66, __v_67, __v_68, __v_81, __v_82, __v_83, __v_84, __v_117, __v_118, __v_119, __v_120, __v_69, __v_70, __v_71, __v_72, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_85, __v_86, __v_87, __v_88, __v_101, __v_102, __v_103, __v_104, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -7828,7 +7906,7 @@ fn aiur_fn_76( let __v_705: G = __r_arr[30]; let __v_706: G = __r_arr[31]; let __ret: [G; OUT_76] = [__v_675, __v_676, __v_677, __v_678, __v_679, __v_680, __v_681, __v_682, __v_683, __v_684, __v_685, __v_686, __v_687, __v_688, __v_689, __v_690, __v_691, __v_692, __v_693, __v_694, __v_695, __v_696, __v_697, __v_698, __v_699, __v_700, __v_701, __v_702, __v_703, __v_704, __v_705, __v_706]; - record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[76].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -7839,21 +7917,22 @@ const INPUT_SIZE_77: usize = 1; const IN_77: usize = 1; const OUT_77: usize = 2; fn aiur_fn_77( - inp: [G; IN_77], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_77], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(77); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_77] = [__v_2, __v_3]; - record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[77].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -7867,18 +7946,19 @@ const INPUT_SIZE_78: usize = 1; const IN_78: usize = 1; const OUT_78: usize = 2; fn aiur_fn_78( - inp: [G; IN_78], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_78], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(78); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __ret: [G; OUT_78] = [__v_1, __v_2]; - record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[78].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7887,24 +7967,25 @@ const INPUT_SIZE_79: usize = 1; const IN_79: usize = 1; const OUT_79: usize = 2; fn aiur_fn_79( - inp: [G; IN_79], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_79], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(79); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(256); let __v_6: G = (__v_5 * __v_3); let __v_7: G = (__v_1 + __v_6); let __ret: [G; OUT_79] = [__v_7, __v_4]; - record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[79].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7913,17 +7994,18 @@ const INPUT_SIZE_80: usize = 1; const IN_80: usize = 1; const OUT_80: usize = 10; fn aiur_fn_80( - inp: [G; IN_80], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_80], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(80); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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); @@ -7936,7 +8018,7 @@ fn aiur_fn_80( let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __ret: [G; OUT_80] = [__v_7, __v_1, __v_3, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_4]; - record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[80].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7945,23 +8027,24 @@ const INPUT_SIZE_81: usize = 1; const IN_81: usize = 1; const OUT_81: usize = 10; fn aiur_fn_81( - inp: [G; IN_81], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_81], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(81); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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); @@ -7978,7 +8061,7 @@ fn aiur_fn_81( let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __ret: [G; OUT_81] = [__v_17, __v_1, __v_3, __v_5, __v_7, __v_18, __v_19, __v_20, __v_21, __v_8]; - record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[81].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -7987,39 +8070,40 @@ const INPUT_SIZE_82: usize = 1; const IN_82: usize = 1; const OUT_82: usize = 9; fn aiur_fn_82( - inp: [G; IN_82], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_82], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(82); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __ret: [G; OUT_82] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_16]; - record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[82].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8028,14 +8112,15 @@ const INPUT_SIZE_83: usize = 1; const IN_83: usize = 1; const OUT_83: usize = 2; fn aiur_fn_83( - inp: [G; IN_83], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_83], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + record.checkpoint(83); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8067,7 +8152,7 @@ fn aiur_fn_83( let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_1 + __v_29); let __ret: [G; OUT_83] = [__v_30, __v_9]; - record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[83].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8076,14 +8161,15 @@ const INPUT_SIZE_84: usize = 1; const IN_84: usize = 1; const OUT_84: usize = 33; fn aiur_fn_84( - inp: [G; IN_84], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_84], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + record.checkpoint(84); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8093,7 +8179,7 @@ fn aiur_fn_84( let __v_7: G = __r_arr[6]; let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8103,7 +8189,7 @@ fn aiur_fn_84( let __v_16: G = __r_arr[6]; let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8113,7 +8199,7 @@ fn aiur_fn_84( let __v_25: G = __r_arr[6]; let __v_26: G = __r_arr[7]; let __v_27: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8124,7 +8210,7 @@ fn aiur_fn_84( let __v_35: G = __r_arr[7]; let __v_36: G = __r_arr[8]; let __ret: [G; OUT_84] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[84].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8133,25 +8219,26 @@ const INPUT_SIZE_85: usize = 2; const IN_85: usize = 2; const OUT_85: usize = 2; fn aiur_fn_85( - inp: [G; IN_85], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_85], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(85); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_4, __v_0]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8161,7 +8248,7 @@ fn aiur_fn_85( let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8171,7 +8258,7 @@ fn aiur_fn_85( let __v_17: G = __r_arr[6]; let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8181,7 +8268,7 @@ fn aiur_fn_85( let __v_26: G = __r_arr[6]; let __v_27: G = __r_arr[7]; let __v_28: G = __r_arr[8]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[82].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i)?; } record.function_queries[82].output_at(__i).to_array::() }, _ => aiur_fn_82(__key, 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]; @@ -8193,14 +8280,14 @@ fn aiur_fn_85( let __v_37: G = __r_arr[8]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = G::from_u64(0); - let __v_43: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_85] = [__v_44, __v_41]; - record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[85].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8211,304 +8298,305 @@ const INPUT_SIZE_86: usize = 2; const IN_86: usize = 2; const OUT_86: usize = 2; fn aiur_fn_86( - inp: [G; IN_86], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_86], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(86); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 6] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_4, __v_0]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[83].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i)?; } record.function_queries[83].output_at(__i).to_array::() }, _ => aiur_fn_83(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(2); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(3); let __v_10: G = G::from_u64(3); - let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_11, __v_7]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(4); let __v_10: G = G::from_u64(4); - let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_11, __v_7]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(5); - let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_10, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_11, __v_7]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(6); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_15, __v_11]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(7); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_15, __v_11]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(8); let __v_14: G = G::from_u64(0); - let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 6] = [__v_12, __v_13, __v_4, __v_6, __v_14, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_15, __v_11]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(9); let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 6] = [__v_10, __v_11, __v_4, __v_12, __v_12, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_13, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 12u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 13u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 14u64 => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(2); let __v_13: G = G::from_u64(0); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(2); let __v_13: G = G::from_u64(1); - let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_10, __v_11, __v_12, __v_13, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_86] = [__v_14, __v_9]; - record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[86].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8521,36 +8609,37 @@ const INPUT_SIZE_87: usize = 2; const IN_87: usize = 2; const OUT_87: usize = 2; fn aiur_fn_87( - inp: [G; IN_87], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(87); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_87] = [__v_4, __v_0]; - record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[87].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_87] = [__v_9, __v_7]; - record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[87].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8561,24 +8650,25 @@ const INPUT_SIZE_88: usize = 1; const IN_88: usize = 1; const OUT_88: usize = 3; fn aiur_fn_88( - inp: [G; IN_88], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + record.checkpoint(88); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, 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]; - record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[88].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8587,42 +8677,43 @@ const INPUT_SIZE_89: usize = 2; const IN_89: usize = 2; const OUT_89: usize = 2; fn aiur_fn_89( - inp: [G; IN_89], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(89); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_89] = [__v_4, __v_0]; - record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[89].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_7, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = G::from_u64(0); - let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_12, __v_2, __v_6, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_89] = [__v_13, __v_11]; - record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[89].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8633,20 +8724,21 @@ const INPUT_SIZE_90: usize = 3; const IN_90: usize = 3; const OUT_90: usize = 1; fn aiur_fn_90( - inp: [G; IN_90], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(90); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(0); let __ret: [G; OUT_90] = [__v_3]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8657,11 +8749,11 @@ fn aiur_fn_90( let __v_5: G = (__v_0 - __v_4); let __v_6: G = G::from_u64(1); let __v_7: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_5, __v_7, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_3 + __v_8); let __ret: [G; OUT_90] = [__v_9]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -8669,10 +8761,10 @@ fn aiur_fn_90( let __v_4: G = (__v_0 - __v_3); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_4, __v_6, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_90] = [__v_7]; - record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[90].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -8685,14 +8777,15 @@ const INPUT_SIZE_91: usize = 1; const IN_91: usize = 1; const OUT_91: usize = 63; fn aiur_fn_91( - inp: [G; IN_91], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + record.checkpoint(91); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -8703,7 +8796,7 @@ fn aiur_fn_91( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -8714,7 +8807,7 @@ fn aiur_fn_91( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[81].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i)?; } record.function_queries[81].output_at(__i).to_array::() }, _ => aiur_fn_81(__key, 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]; @@ -8725,7 +8818,7 @@ fn aiur_fn_91( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -8736,29 +8829,29 @@ fn aiur_fn_91( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_42]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_44, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_44, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_48, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_48, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_52, __v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_51, __v_55, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, 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); @@ -8773,10 +8866,10 @@ fn aiur_fn_91( let __v_66: G = G::from_u8(__gb[5]); let __v_67: G = G::from_u8(__gb[6]); let __v_68: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_61; let __vj = __v_62; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_63; let __vj = __v_64; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_65; let __vj = __v_66; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_67; let __vj = __v_68; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_61; let __vj = __v_62; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_63; let __vj = __v_64; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_65; let __vj = __v_66; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_67; let __vj = __v_68; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_69: G = G::from_u64(1020); let __v_70: G = (__v_68 - __v_69); let __v_71: G = (__v_67 + __v_70); @@ -8830,10 +8923,10 @@ fn aiur_fn_91( 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); }; + if !unconstrained { let __vi = __v_107; let __vj = __v_108; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_109; let __vj = __v_110; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_111; let __vj = __v_112; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_113; let __vj = __v_114; 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); @@ -8886,10 +8979,10 @@ fn aiur_fn_91( let __v_157: G = G::from_u8(__gb[5]); let __v_158: G = G::from_u8(__gb[6]); let __v_159: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_152; let __vj = __v_153; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_154; let __vj = __v_155; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_156; let __vj = __v_157; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_158; let __vj = __v_159; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_152; let __vj = __v_153; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_154; let __vj = __v_155; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_156; let __vj = __v_157; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_158; let __vj = __v_159; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_160: G = G::from_u64(1020); let __v_161: G = (__v_159 - __v_160); let __v_162: G = (__v_158 + __v_161); @@ -8934,7 +9027,7 @@ fn aiur_fn_91( return Err(ExecError::AssertEqMismatch { lhs: __v_195.as_canonical_u64(), rhs: __v_196.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_91] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_54]; - record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[91].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -8943,69 +9036,70 @@ const INPUT_SIZE_92: usize = 57; const IN_92: usize = 57; const OUT_92: usize = 1; fn aiur_fn_92( - inp: [G; IN_92], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __v_44: G = inp[44]; - let __v_45: G = inp[45]; - let __v_46: G = inp[46]; - let __v_47: G = inp[47]; - let __v_48: G = inp[48]; - let __v_49: G = inp[49]; - let __v_50: G = inp[50]; - let __v_51: G = inp[51]; - let __v_52: G = inp[52]; - let __v_53: G = inp[53]; - let __v_54: G = inp[54]; - let __v_55: G = inp[55]; - let __v_56: G = inp[56]; + record.checkpoint(92); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __v_44: G = inp.values()[44]; + let __v_45: G = inp.values()[45]; + let __v_46: G = inp.values()[46]; + let __v_47: G = inp.values()[47]; + let __v_48: G = inp.values()[48]; + let __v_49: G = inp.values()[49]; + let __v_50: G = inp.values()[50]; + let __v_51: G = inp.values()[51]; + let __v_52: G = inp.values()[52]; + let __v_53: G = inp.values()[53]; + let __v_54: G = inp.values()[54]; + let __v_55: G = inp.values()[55]; + let __v_56: G = inp.values()[56]; let __v_57: G = G::from_u64(0); let __v_58: G = G::from_u64(0); let __v_59: G = G::from_u64(0); @@ -9013,15 +9107,15 @@ fn aiur_fn_92( let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(0); let __v_63: G = G::from_u64(0); - let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_65: G = { let __values: [G; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_92] = [__v_70]; - record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[92].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9030,28 +9124,29 @@ const INPUT_SIZE_93: usize = 2; const IN_93: usize = 2; const OUT_93: usize = 3; fn aiur_fn_93( - inp: [G; IN_93], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(93); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_93] = [__v_4, __v_7, __v_0]; - record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[93].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9062,7 +9157,7 @@ fn aiur_fn_93( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9073,7 +9168,7 @@ fn aiur_fn_93( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[81].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i)?; } record.function_queries[81].output_at(__i).to_array::() }, _ => aiur_fn_81(__key, 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]; @@ -9084,7 +9179,7 @@ fn aiur_fn_93( let __v_29: G = __r_arr[7]; let __v_30: G = __r_arr[8]; let __v_31: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9095,29 +9190,29 @@ fn aiur_fn_93( let __v_39: G = __r_arr[7]; let __v_40: G = __r_arr[8]; let __v_41: G = __r_arr[9]; - let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[78].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i)?; } record.function_queries[78].output_at(__i).to_array::() }, _ => aiur_fn_78(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_45, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_45, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[86].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i)?; } record.function_queries[86].output_at(__i).to_array::() }, _ => aiur_fn_86(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_49, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[87].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i)?; } record.function_queries[87].output_at(__i).to_array::() }, _ => aiur_fn_87(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_53, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_53, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[89].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i)?; } record.function_queries[89].output_at(__i).to_array::() }, _ => aiur_fn_89(__key, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = G::from_u64(0); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_52, __v_56, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_52, __v_56, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[90].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i)?; } record.function_queries[90].output_at(__i).to_array::() }, _ => aiur_fn_90(__key, 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); @@ -9132,10 +9227,10 @@ fn aiur_fn_93( let __v_67: G = G::from_u8(__gb[5]); let __v_68: G = G::from_u8(__gb[6]); let __v_69: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_66; let __vj = __v_67; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_68; let __vj = __v_69; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_66; let __vj = __v_67; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_68; let __vj = __v_69; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_70: G = G::from_u64(1020); let __v_71: G = (__v_69 - __v_70); let __v_72: G = (__v_68 + __v_71); @@ -9189,10 +9284,10 @@ fn aiur_fn_93( let __v_113: G = G::from_u8(__gb[5]); let __v_114: G = G::from_u8(__gb[6]); let __v_115: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_108; let __vj = __v_109; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_110; let __vj = __v_111; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_112; let __vj = __v_113; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_114; let __vj = __v_115; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_108; let __vj = __v_109; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_110; let __vj = __v_111; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_112; let __vj = __v_113; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_114; let __vj = __v_115; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_116: G = G::from_u64(1020); let __v_117: G = (__v_115 - __v_116); let __v_118: G = (__v_114 + __v_117); @@ -9245,10 +9340,10 @@ fn aiur_fn_93( let __v_158: G = G::from_u8(__gb[5]); let __v_159: G = G::from_u8(__gb[6]); let __v_160: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_153; let __vj = __v_154; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_155; let __vj = __v_156; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_157; let __vj = __v_158; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_159; let __vj = __v_160; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_153; let __vj = __v_154; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_155; let __vj = __v_156; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_157; let __vj = __v_158; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_159; let __vj = __v_160; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_161: G = G::from_u64(1020); let __v_162: G = (__v_160 - __v_161); let __v_163: G = (__v_159 + __v_162); @@ -9294,12 +9389,12 @@ fn aiur_fn_93( } let __v_198: G = G::from_u64(1); let __v_199: G = (__v_1 - __v_198); - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_55, __v_199]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_55, __v_199]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_200: G = __r_arr[0]; let __v_201: G = __r_arr[1]; let __v_202: G = __r_arr[2]; let __v_203: G = G::from_u64(0); - let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_204: G = { let __values: [G; 8] = [__v_203, __v_46, __v_44, __v_50, __v_32, __v_54, __v_42, __v_200]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_205: G = G::from_u64(0); let __v_206: G = G::from_u64(0); let __v_207: G = G::from_u64(0); @@ -9307,15 +9402,15 @@ fn aiur_fn_93( let __v_209: G = G::from_u64(0); let __v_210: G = G::from_u64(0); let __v_211: G = G::from_u64(0); - let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_217: G = { let __values: [G; 10] = [__v_206, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_216]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_218: G = { let __values: [G; 10] = [__v_205, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_217]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_212: G = { let __values: [G; 10] = [__v_211, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_201]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_213: G = { let __values: [G; 10] = [__v_210, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_212]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_214: G = { let __values: [G; 10] = [__v_209, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_213]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_215: G = { let __values: [G; 10] = [__v_208, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_214]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_216: G = { let __values: [G; 10] = [__v_207, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_215]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_93] = [__v_204, __v_218, __v_202]; - record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[93].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9326,14 +9421,15 @@ const INPUT_SIZE_94: usize = 1; const IN_94: usize = 1; const OUT_94: usize = 3; fn aiur_fn_94( - inp: [G; IN_94], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(94); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -9341,19 +9437,19 @@ fn aiur_fn_94( let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); let __ret: [G; OUT_94] = [__v_3, __v_4, __v_2]; - record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[94].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[85].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i)?; } record.function_queries[85].output_at(__i).to_array::() }, _ => aiur_fn_85(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); let __ret: [G; OUT_94] = [__v_7, __v_5, __v_6]; - record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[94].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9364,30 +9460,31 @@ const INPUT_SIZE_95: usize = 2; const IN_95: usize = 2; const OUT_95: usize = 2; fn aiur_fn_95( - inp: [G; IN_95], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(95); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_95] = [__v_4, __v_0]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[79].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i)?; } record.function_queries[79].output_at(__i).to_array::() }, _ => aiur_fn_79(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -9395,17 +9492,17 @@ fn aiur_fn_95( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_95] = [__v_11, __v_7]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_95] = [__v_10, __v_7]; - record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[95].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -9418,14 +9515,15 @@ const INPUT_SIZE_96: usize = 1; const IN_96: usize = 1; const OUT_96: usize = 9; fn aiur_fn_96( - inp: [G; IN_96], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + record.checkpoint(96); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9436,7 +9534,7 @@ fn aiur_fn_96( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9447,7 +9545,7 @@ fn aiur_fn_96( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9458,7 +9556,7 @@ fn aiur_fn_96( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9469,7 +9567,7 @@ fn aiur_fn_96( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9480,7 +9578,7 @@ fn aiur_fn_96( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9491,7 +9589,7 @@ fn aiur_fn_96( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9511,16 +9609,16 @@ fn aiur_fn_96( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_96] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70]; - record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[96].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9529,14 +9627,15 @@ const INPUT_SIZE_97: usize = 1; const IN_97: usize = 1; const OUT_97: usize = 13; fn aiur_fn_97( - inp: [G; IN_97], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + record.checkpoint(97); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9547,7 +9646,7 @@ fn aiur_fn_97( let __v_8: G = __r_arr[7]; let __v_9: G = __r_arr[8]; let __v_10: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9558,7 +9657,7 @@ fn aiur_fn_97( let __v_18: G = __r_arr[7]; let __v_19: G = __r_arr[8]; let __v_20: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9569,7 +9668,7 @@ fn aiur_fn_97( let __v_28: G = __r_arr[7]; let __v_29: G = __r_arr[8]; let __v_30: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9580,7 +9679,7 @@ fn aiur_fn_97( let __v_38: G = __r_arr[7]; let __v_39: G = __r_arr[8]; let __v_40: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9591,7 +9690,7 @@ fn aiur_fn_97( let __v_48: G = __r_arr[7]; let __v_49: G = __r_arr[8]; let __v_50: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9602,7 +9701,7 @@ fn aiur_fn_97( let __v_58: G = __r_arr[7]; let __v_59: G = __r_arr[8]; let __v_60: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9622,15 +9721,15 @@ fn aiur_fn_97( let __v_77: G = G::from_u64(0); let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_80: G = { let __values: [G; 10] = [__v_78, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_81: G = { let __values: [G; 10] = [__v_77, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_80]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_82: G = { let __values: [G; 10] = [__v_76, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_83: G = { let __values: [G; 10] = [__v_75, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_84: G = { let __values: [G; 10] = [__v_74, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -9641,23 +9740,23 @@ fn aiur_fn_97( let __v_95: G = __r_arr[7]; let __v_96: G = __r_arr[8]; let __v_97: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_97, __v_88]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_100]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_100]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[94].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i)?; } record.function_queries[94].output_at(__i).to_array::() }, _ => aiur_fn_94(__key, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; let __v_102: G = __r_arr[1]; let __v_103: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_103, __v_88]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(0); - let __v_107: G = { let __values: [G; 10] = [__v_106, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_99]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_87, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_87, __v_107]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, 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]; - record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[97].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9666,27 +9765,28 @@ const INPUT_SIZE_98: usize = 5; const IN_98: usize = 5; const OUT_98: usize = 1; fn aiur_fn_98( - inp: [G; IN_98], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(98); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(0); - let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_3, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_98] = [__v_12]; - record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[98].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9695,63 +9795,64 @@ const INPUT_SIZE_99: usize = 33; const IN_99: usize = 33; const OUT_99: usize = 1; fn aiur_fn_99( - inp: [G; IN_99], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + record.checkpoint(99); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __ret: [G; OUT_99] = [__v_40]; - record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[99].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9760,46 +9861,47 @@ const INPUT_SIZE_100: usize = 32; const IN_100: usize = 32; const OUT_100: usize = 32; fn aiur_fn_100( - inp: [G; IN_100], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(100); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; let __ret: [G; OUT_100] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; - record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[100].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9808,14 +9910,15 @@ const INPUT_SIZE_101: usize = 2; const IN_101: usize = 2; const OUT_101: usize = 1; fn aiur_fn_101( - inp: [G; IN_101], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(101); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(103); let __v_3: G = G::from_u64(230); let __v_4: G = G::from_u64(9); @@ -9848,7 +9951,7 @@ fn aiur_fn_101( let __v_31: G = G::from_u64(205); let __v_32: G = G::from_u64(224); let __v_33: G = G::from_u64(91); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -9881,7 +9984,7 @@ fn aiur_fn_101( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_66: G = __loaded[0]; let __v_67: G = __loaded[1]; let __v_68: G = __loaded[2]; @@ -9947,7 +10050,7 @@ fn aiur_fn_101( let __v_128: G = G::from_u64(0); let __v_129: G = G::from_u64(0); let __v_130: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_130, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_124, __v_125, __v_126, __v_107, __v_127, __v_128, __v_129, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -9980,9 +10083,9 @@ fn aiur_fn_101( let __v_160: G = __r_arr[29]; let __v_161: G = __r_arr[30]; let __v_162: G = __r_arr[31]; - let __v_163: G = { let __values: [G; 32] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_101] = [__v_163]; - record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[101].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -9991,28 +10094,29 @@ const INPUT_SIZE_102: usize = 3; const IN_102: usize = 3; const OUT_102: usize = 1; fn aiur_fn_102( - inp: [G; IN_102], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(102); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_102] = [__v_3]; - record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[102].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_102] = [__v_3]; - record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[102].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10023,15 +10127,16 @@ const INPUT_SIZE_103: usize = 2; const IN_103: usize = 2; const OUT_103: usize = 1; fn aiur_fn_103( - inp: [G; IN_103], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(103); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10039,7 +10144,7 @@ fn aiur_fn_103( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_103] = [__v_5]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -10049,14 +10154,14 @@ fn aiur_fn_103( 1u64 => { let __v_7: G = G::from_u64(1); let __ret: [G; OUT_103] = [__v_7]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_103] = [__v_7]; - record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[103].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10072,16 +10177,17 @@ const INPUT_SIZE_104: usize = 3; const IN_104: usize = 3; const OUT_104: usize = 1; fn aiur_fn_104( - inp: [G; IN_104], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(104); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -10089,13 +10195,13 @@ fn aiur_fn_104( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_104] = [__v_8]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -10105,14 +10211,14 @@ fn aiur_fn_104( let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_11]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -10125,19 +10231,19 @@ fn aiur_fn_104( let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_104] = [__v_21]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_104] = [__v_23]; - record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[104].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10160,16 +10266,17 @@ const INPUT_SIZE_105: usize = 3; const IN_105: usize = 3; const OUT_105: usize = 1; fn aiur_fn_105( - inp: [G; IN_105], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(105); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -10177,29 +10284,29 @@ fn aiur_fn_105( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_105] = [__v_8]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_10]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -10212,19 +10319,19 @@ fn aiur_fn_105( let __v_19: G = __loaded[9]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __ret: [G; OUT_105] = [__v_20]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_5, __v_8, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_4, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_105] = [__v_22]; - record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[105].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -10247,15 +10354,16 @@ const INPUT_SIZE_106: usize = 2; const IN_106: usize = 2; const OUT_106: usize = 11; fn aiur_fn_106( - inp: [G; IN_106], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(106); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -10298,10 +10406,10 @@ fn aiur_fn_106( let __v_38: G = G::from_u8(__gb[5]); let __v_39: G = G::from_u8(__gb[6]); let __v_40: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_33; let __vj = __v_34; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_35; let __vj = __v_36; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_37; let __vj = __v_38; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_39; let __vj = __v_40; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_33; let __vj = __v_34; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_35; let __vj = __v_36; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_37; let __vj = __v_38; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_39; let __vj = __v_40; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_41: G = G::from_u64(1020); let __v_42: G = (__v_40 - __v_41); let __v_43: G = (__v_39 + __v_42); @@ -10347,11 +10455,11 @@ fn aiur_fn_106( } let __v_78: G = G::from_u64(1); let __ret: [G; OUT_106] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_11, __v_1, __v_78]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_12: G = __loaded[0]; let __v_13: G = __loaded[1]; let __v_14: G = __loaded[2]; @@ -10367,11 +10475,11 @@ fn aiur_fn_106( let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); let __ret: [G; OUT_106] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10384,7 +10492,7 @@ fn aiur_fn_106( let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; let __ret: [G; OUT_106] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[106].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10403,19 +10511,20 @@ const INPUT_SIZE_107: usize = 6; const IN_107: usize = 6; const OUT_107: usize = 1; fn aiur_fn_107( - inp: [G; IN_107], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + record.checkpoint(107); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10429,7 +10538,7 @@ fn aiur_fn_107( let __v_16: G = __r_arr[10]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -10454,7 +10563,7 @@ fn aiur_fn_107( 0u64 => { match __v_24.as_canonical_u64() { 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -10551,7 +10660,7 @@ fn aiur_fn_107( let __v_118: G = G::from_u64(0); let __v_119: G = G::from_u64(0); let __v_120: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; @@ -10586,7 +10695,7 @@ fn aiur_fn_107( let __v_152: G = G::from_u64(0); let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_154, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_147, __v_148, __v_149, __v_130, __v_150, __v_151, __v_152, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -10619,69 +10728,69 @@ fn aiur_fn_107( let __v_184: G = __r_arr[29]; let __v_185: G = __r_arr[30]; let __v_186: G = __r_arr[31]; - let __v_187: G = { let __values: [G; 34] = [__v_153, __v_5, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_107] = [__v_187]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { let __ret: [G; OUT_107] = [__v_5]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_14, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10693,7 +10802,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_25, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10705,7 +10814,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_36, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10717,7 +10826,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_47, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10729,7 +10838,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_58, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_58, __v_59]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10741,7 +10850,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_69, __v_70]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_69, __v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10753,7 +10862,7 @@ fn aiur_fn_107( 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_106] = { let __args: [G; IN_106] = [__v_80, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_80, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[106].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i)?; } record.function_queries[106].output_at(__i).to_array::() }, _ => aiur_fn_106(__key, 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]; @@ -10774,7 +10883,7 @@ fn aiur_fn_107( let __v_100: G = (__v_27 + __v_99); let __v_101: G = (__v_16 + __v_100); let __v_102: G = (__v_94 * __v_101); - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_91.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; @@ -10787,7 +10896,7 @@ fn aiur_fn_107( let __v_112: G = __loaded[9]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_103.as_canonical_u64() { 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_92.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_113: G = __loaded[0]; let __v_114: G = __loaded[1]; let __v_115: G = __loaded[2]; @@ -10816,7 +10925,7 @@ fn aiur_fn_107( let __v_118: G = (__v_113 * __v_116); let __v_119: G = (__v_116 - __v_118); let __v_120: G = (__v_113 + __v_119); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; @@ -10825,7 +10934,7 @@ fn aiur_fn_107( let __v_126: G = __loaded[5]; let __v_127: G = __loaded[6]; let __v_128: G = __loaded[7]; - let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[4].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i)?; } record.function_queries[4].output_at(__i).to_array::() }, _ => aiur_fn_4(__key, 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); @@ -10834,7 +10943,7 @@ fn aiur_fn_107( let __v_134: G = (__v_133 * __v_130); let __v_135: G = (__v_132 + __v_134); let __v_136: G = (__v_117 + __v_135); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_137: G = __loaded[0]; let __v_138: G = __loaded[1]; let __v_139: G = __loaded[2]; @@ -10867,7 +10976,7 @@ fn aiur_fn_107( let __v_166: G = __loaded[29]; let __v_167: G = __loaded[30]; let __v_168: G = __loaded[31]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_169: G = __loaded[0]; let __v_170: G = __loaded[1]; let __v_171: G = __loaded[2]; @@ -10899,7 +11008,7 @@ fn aiur_fn_107( let __v_197: G = G::from_u64(0); let __v_198: G = G::from_u64(0); let __v_199: G = G::from_u64(0); - let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_199, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_102, __v_193, __v_194, __v_195, __v_136, __v_196, __v_197, __v_198, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[76].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i)?; } record.function_queries[76].output_at(__i).to_array::() }, _ => aiur_fn_76(__key, 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]; @@ -10935,9 +11044,9 @@ fn aiur_fn_107( match __v_113.as_canonical_u64() { 1u64 => { let __v_232: G = G::from_u64(0); - let __v_233: G = { let __values: [G; 34] = [__v_232, __v_5, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_107] = [__v_233]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -10976,7 +11085,7 @@ fn aiur_fn_107( let __v_262: G = G::from_u64(224); let __v_263: G = G::from_u64(91); let __v_264: G = G::from_u64(0); - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_265: G = __loaded[0]; let __v_266: G = __loaded[1]; let __v_267: G = __loaded[2]; @@ -10985,7 +11094,7 @@ fn aiur_fn_107( let __v_270: G = __loaded[5]; let __v_271: G = __loaded[6]; let __v_272: G = __loaded[7]; - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __cu = unconstrained; let __hit = record.function_queries[12].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i); } let __ret: [G; OUT_12] = unsafe { *(record.function_queries[12].output_at(__i).as_ptr() as *const [G; OUT_12]) }; __ret }, _ => aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_265, __v_266, __v_267, __v_268, __v_269, __v_270, __v_271, __v_272]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[12].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[12].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[12].bump_multiplicity(__i)?; } record.function_queries[12].output_at(__i).to_array::() }, _ => aiur_fn_12(__key, 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]; @@ -10994,24 +11103,24 @@ fn aiur_fn_107( let __v_278: G = __r_arr[5]; let __v_279: G = __r_arr[6]; let __v_280: G = __r_arr[7]; - let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_281: G = { let __values: [G; 8] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_282: G = { let __values: [G; 32] = [__v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_264, __v_281, __v_282, __v_284]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_285: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_285]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_91, __v_92, __v_233, __v_3, __v_234, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; let __ret: [G; OUT_107] = [__v_235]; - record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[107].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11026,13 +11135,14 @@ const INPUT_SIZE_108: usize = 1; const IN_108: usize = 1; const OUT_108: usize = 32; fn aiur_fn_108( - inp: [G; IN_108], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(108); + let __v_0: G = inp.values()[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); @@ -11067,7 +11177,7 @@ fn aiur_fn_108( let __v_32: G = G::from_u64(91); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 10] = [__v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -11077,14 +11187,14 @@ fn aiur_fn_108( let __v_42: G = G::from_u64(0); let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); - let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 8] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_46: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -11118,7 +11228,7 @@ fn aiur_fn_108( let __v_81: G = __r_arr[30]; let __v_82: G = __r_arr[31]; let __ret: [G; OUT_108] = [__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]; - record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[108].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -11127,16 +11237,17 @@ const INPUT_SIZE_109: usize = 3; const IN_109: usize = 3; const OUT_109: usize = 1; fn aiur_fn_109( - inp: [G; IN_109], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } }; + record.checkpoint(109); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[104].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i)?; } record.function_queries[104].output_at(__i).to_array::() }, _ => aiur_fn_104(__key, 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); @@ -11172,7 +11283,7 @@ fn aiur_fn_109( let __v_35: G = G::from_u64(91); let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); - let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); @@ -11182,14 +11293,14 @@ fn aiur_fn_109( let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 8] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_49: G = { let __values: [G; 32] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_50: G = G::from_u64(1); let __v_51: G = G::from_u64(1); - let __v_52: G = { let __values: [G; 34] = [__v_50, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_38, __v_3, __v_39, __v_48, __v_49, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[107].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i)?; } record.function_queries[107].output_at(__i).to_array::() }, _ => aiur_fn_107(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_53]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -11222,9 +11333,9 @@ fn aiur_fn_109( let __v_83: G = __r_arr[29]; let __v_84: G = __r_arr[30]; let __v_85: G = __r_arr[31]; - let __v_86: G = { let __values: [G; 32] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_109] = [__v_86]; - record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[109].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -11233,31 +11344,32 @@ const INPUT_SIZE_110: usize = 4; const IN_110: usize = 4; const OUT_110: usize = 1; fn aiur_fn_110( - inp: [G; IN_110], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } }; + record.checkpoint(110); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[103].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i)?; } record.function_queries[103].output_at(__i).to_array::() }, _ => aiur_fn_103(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_110] = [__v_3]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[109].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i)?; } record.function_queries[109].output_at(__i).to_array::() }, _ => aiur_fn_109(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_110] = [__v_6]; - record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[110].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11268,14 +11380,15 @@ const INPUT_SIZE_111: usize = 1; const IN_111: usize = 1; const OUT_111: usize = 1; fn aiur_fn_111( - inp: [G; IN_111], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(111); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11283,17 +11396,17 @@ fn aiur_fn_111( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_111] = [__v_4]; - record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[111].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, 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_111] = [__v_7]; - record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[111].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11307,15 +11420,16 @@ const INPUT_SIZE_112: usize = 2; const IN_112: usize = 2; const OUT_112: usize = 1; fn aiur_fn_112( - inp: [G; IN_112], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(112); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11325,11 +11439,11 @@ fn aiur_fn_112( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_112] = [__v_1]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -11339,7 +11453,7 @@ fn aiur_fn_112( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_112] = [__v_0]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -11347,16 +11461,16 @@ fn aiur_fn_112( _ => { match __v_9.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[0].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i)?; } record.function_queries[0].output_at(__i).to_array::() }, _ => aiur_fn_0(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_15, __v_3, __v_4, __v_5, __v_6, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_112] = [__v_17]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11371,20 +11485,20 @@ fn aiur_fn_112( return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: None }); } let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_7, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_112] = [__v_19]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 6] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_112] = [__v_19]; - record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[112].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11411,14 +11525,15 @@ const INPUT_SIZE_113: usize = 1; const IN_113: usize = 1; const OUT_113: usize = 2; fn aiur_fn_113( - inp: [G; IN_113], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(113); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11429,16 +11544,16 @@ fn aiur_fn_113( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 6] = [__v_7, __v_8, __v_8, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_113] = [__v_9, __v_12]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -11450,25 +11565,25 @@ fn aiur_fn_113( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 6] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_113] = [__v_17, __v_20]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[113].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i)?; } record.function_queries[113].output_at(__i).to_array::() }, _ => aiur_fn_113(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { let __values: [G; 6] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_17: G = G::from_u64(0); - let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 6] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_113] = [__v_16, __v_18]; - record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[113].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11487,14 +11602,15 @@ const INPUT_SIZE_114: usize = 1; const IN_114: usize = 1; const OUT_114: usize = 1; fn aiur_fn_114( - inp: [G; IN_114], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(114); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -11504,11 +11620,11 @@ fn aiur_fn_114( match __v_1.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_114] = [__v_0]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -11518,21 +11634,21 @@ fn aiur_fn_114( match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_114] = [__v_0]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[113].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i)?; } record.function_queries[113].output_at(__i).to_array::() }, _ => aiur_fn_113(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_15, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[112].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i)?; } record.function_queries[112].output_at(__i).to_array::() }, _ => aiur_fn_112(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __ret: [G; OUT_114] = [__v_17]; - record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[114].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11551,23 +11667,24 @@ const INPUT_SIZE_115: usize = 4; const IN_115: usize = 4; const OUT_115: usize = 1; fn aiur_fn_115( - inp: [G; IN_115], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(115); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); if (__v_7 != __v_8) { @@ -11575,28 +11692,28 @@ fn aiur_fn_115( } let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 6] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_115] = [__v_11]; - record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[115].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_8, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[109].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i)?; } record.function_queries[109].output_at(__i).to_array::() }, _ => aiur_fn_109(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6, __v_9, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 6] = [__v_11, __v_12, __v_5, __v_8, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_115] = [__v_14]; - record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[115].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11615,17 +11732,18 @@ const INPUT_SIZE_116: usize = 4; const IN_116: usize = 4; const OUT_116: usize = 2; fn aiur_fn_116( - inp: [G; IN_116], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(116); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -11636,23 +11754,23 @@ fn aiur_fn_116( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_12, __v_1]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_5.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_111] = { let __args: [G; IN_111] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; @@ -11663,56 +11781,56 @@ fn aiur_fn_116( 0u64 => { match __v_15.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_13 - __v_23); let __v_25: G = G::from_bool((__v_24 == G::ZERO)); match __v_25.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[101].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i)?; } record.function_queries[101].output_at(__i).to_array::() }, _ => aiur_fn_101(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_19, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_19, __v_1, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_7, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_7, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_17, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_17, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[105].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i)?; } record.function_queries[105].output_at(__i).to_array::() }, _ => aiur_fn_105(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: None }); } let __v_32: G = G::from_u64(0); - let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 6] = [__v_32, __v_13, __v_12, __v_7, __v_27, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_33, __v_29]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[102].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i)?; } record.function_queries[102].output_at(__i).to_array::() }, _ => aiur_fn_102(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_28, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_28, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_33, __v_13, __v_12, __v_7, __v_30, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_34, __v_32]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11730,23 +11848,23 @@ fn aiur_fn_116( } }, 1u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_11, __v_8, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[102].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i)?; } record.function_queries[102].output_at(__i).to_array::() }, _ => aiur_fn_102(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_7, __v_2, __v_3, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[110].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i)?; } record.function_queries[110].output_at(__i).to_array::() }, _ => aiur_fn_110(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); - let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_26, __v_27, __v_27, __v_27, __v_27, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 6] = [__v_25, __v_13, __v_12, __v_7, __v_24, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_116] = [__v_29, __v_22]; - record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[116].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11777,35 +11895,36 @@ const INPUT_SIZE_117: usize = 4; const IN_117: usize = 4; const OUT_117: usize = 2; fn aiur_fn_117( - inp: [G; IN_117], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(117); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_117] = [__v_0, __v_1]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[117].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_3 - __v_4); - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0, __v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[116].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i)?; } record.function_queries[116].output_at(__i).to_array::() }, _ => aiur_fn_116(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 - __v_8); - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_6, __v_7, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_6, __v_7, __v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __ret: [G; OUT_117] = [__v_10, __v_11]; - record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[117].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11816,26 +11935,27 @@ const INPUT_SIZE_118: usize = 6; const IN_118: usize = 6; const OUT_118: usize = 1; fn aiur_fn_118( - inp: [G; IN_118], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } }; + record.checkpoint(118); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_1, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[115].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i)?; } record.function_queries[115].output_at(__i).to_array::() }, _ => aiur_fn_115(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[114].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i)?; } record.function_queries[114].output_at(__i).to_array::() }, _ => aiur_fn_114(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_4, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_4, __v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[117].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i)?; } record.function_queries[117].output_at(__i).to_array::() }, _ => aiur_fn_117(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -11846,9 +11966,9 @@ fn aiur_fn_118( 0u64 => { match __v_11.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_16 - __v_17); let __v_19: G = G::from_bool((__v_18 == G::ZERO)); @@ -11856,24 +11976,24 @@ fn aiur_fn_118( if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = (__v_25 - __v_14); let __v_27: G = G::from_bool((__v_26 == G::ZERO)); let __ret: [G; OUT_118] = [__v_27]; - record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[118].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11889,31 +12009,32 @@ const INPUT_SIZE_119: usize = 2; const IN_119: usize = 2; const OUT_119: usize = 1; fn aiur_fn_119( - inp: [G; IN_119], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(119); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_119] = [__v_1]; - record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_4, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_119] = [__v_7]; - record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[119].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -11927,15 +12048,16 @@ const INPUT_SIZE_120: usize = 2; const IN_120: usize = 2; const OUT_120: usize = 1; fn aiur_fn_120( - inp: [G; IN_120], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(120); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -11943,23 +12065,23 @@ fn aiur_fn_120( 1u64 => { let __v_5: G = G::from_u64(1); let __ret: [G; OUT_120] = [__v_5]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = (__v_0 * __v_0); - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_120] = [__v_6]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_7: G = (__v_0 * __v_6); let __ret: [G; OUT_120] = [__v_7]; - record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[120].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -11975,30 +12097,31 @@ const INPUT_SIZE_121: usize = 8; const IN_121: usize = 8; const OUT_121: usize = 2; fn aiur_fn_121( - inp: [G; IN_121], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(121); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, 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); @@ -12081,7 +12204,7 @@ fn aiur_fn_121( let __v_82: G = (__v_42 + __v_78); let __v_83: G = (__v_45 + __v_81); let __ret: [G; OUT_121] = [__v_82, __v_83]; - record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[121].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -12090,27 +12213,28 @@ const INPUT_SIZE_122: usize = 2; const IN_122: usize = 2; const OUT_122: usize = 1; fn aiur_fn_122( - inp: [G; IN_122], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(122); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(7); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_0, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_2 * __v_8); let __ret: [G; OUT_122] = [__v_9]; - record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[122].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -12119,21 +12243,22 @@ const INPUT_SIZE_123: usize = 8; const IN_123: usize = 8; const OUT_123: usize = 4; fn aiur_fn_123( - inp: [G; IN_123], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(123); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -12147,11 +12272,11 @@ fn aiur_fn_123( match __v_8.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_123] = [__v_4, __v_5, __v_6, __v_7]; - record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[123].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_18: G = __loaded[0]; let __v_19: G = __loaded[1]; let __v_20: G = __loaded[2]; @@ -12200,13 +12325,13 @@ fn aiur_fn_123( 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_123] = { let __args: [G; IN_123] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_17, __v_21, __v_2, __v_3, __v_54, __v_55, __v_60, __v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, 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_123] = [__v_64, __v_65, __v_66, __v_67]; - record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[123].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12225,15 +12350,16 @@ const INPUT_SIZE_124: usize = 2; const IN_124: usize = 2; const OUT_124: usize = 1; fn aiur_fn_124( - inp: [G; IN_124], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(124); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -12241,7 +12367,7 @@ fn aiur_fn_124( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_124] = [__v_1]; - record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12254,10 +12380,10 @@ fn aiur_fn_124( let __v_11: G = G::from_u8(__gb[5]); let __v_12: G = G::from_u8(__gb[6]); let __v_13: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_12; let __vj = __v_13; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_6; let __vj = __v_7; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_12; let __vj = __v_13; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_14: G = G::from_u64(1020); let __v_15: G = (__v_13 - __v_14); let __v_16: G = (__v_12 + __v_15); @@ -12277,10 +12403,10 @@ fn aiur_fn_124( let __v_29: G = G::from_u8(__gb[5]); let __v_30: G = G::from_u8(__gb[6]); let __v_31: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_30; let __vj = __v_31; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_28; let __vj = __v_29; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_30; let __vj = __v_31; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_32: G = G::from_u64(1020); let __v_33: G = (__v_31 - __v_32); let __v_34: G = (__v_30 + __v_33); @@ -12357,14 +12483,14 @@ fn aiur_fn_124( 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_124] = { let __args: [G; IN_124] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __ret: [G; OUT_124] = [__v_98]; - record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[124].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12378,31 +12504,32 @@ const INPUT_SIZE_125: usize = 2; const IN_125: usize = 2; const OUT_125: usize = 1; fn aiur_fn_125( - inp: [G; IN_125], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(125); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_125] = [__v_1]; - record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[125].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_125] = [__v_6]; - record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[125].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12416,31 +12543,32 @@ const INPUT_SIZE_126: usize = 2; const IN_126: usize = 2; const OUT_126: usize = 1; fn aiur_fn_126( - inp: [G; IN_126], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(126); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_126] = [__v_1]; - record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[126].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[125].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i)?; } record.function_queries[125].output_at(__i).to_array::() }, _ => aiur_fn_125(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_126] = [__v_6]; - record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[126].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12454,26 +12582,27 @@ const INPUT_SIZE_127: usize = 3; const IN_127: usize = 3; const OUT_127: usize = 1; fn aiur_fn_127( - inp: [G; IN_127], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(127); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_127] = [__v_2]; - record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[127].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_3]; - record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[127].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12487,22 +12616,23 @@ const INPUT_SIZE_128: usize = 2; const IN_128: usize = 2; const OUT_128: usize = 1; fn aiur_fn_128( - inp: [G; IN_128], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(128); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_128] = [__v_0]; - record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[128].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12514,12 +12644,12 @@ fn aiur_fn_128( 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_171] = { let __args: [G; IN_171] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_13, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_13, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __ret: [G; OUT_128] = [__v_14]; - record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[128].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12533,49 +12663,50 @@ const INPUT_SIZE_129: usize = 10; const IN_129: usize = 10; const OUT_129: usize = 2; fn aiur_fn_129( - inp: [G; IN_129], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(129); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_129] = [__v_0, __v_12]; - record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[129].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[171].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i)?; } record.function_queries[171].output_at(__i).to_array::() }, _ => aiur_fn_171(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); - let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_10, __v_13, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, 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_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[111].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i)?; } record.function_queries[111].output_at(__i).to_array::() }, _ => aiur_fn_111(__key, 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_129] = [__v_15, __v_16]; - record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[129].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12586,17 +12717,18 @@ const INPUT_SIZE_130: usize = 4; const IN_130: usize = 4; const OUT_130: usize = 2; fn aiur_fn_130( - inp: [G; IN_130], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(130); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -12604,13 +12736,13 @@ fn aiur_fn_130( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_130] = [__v_9, __v_0]; - record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[130].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; @@ -12623,12 +12755,12 @@ fn aiur_fn_130( let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -12647,7 +12779,7 @@ fn aiur_fn_130( 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_130] = { let __args: [G; IN_130] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_36, __v_6, __v_16, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, 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); @@ -12693,9 +12825,9 @@ fn aiur_fn_130( let __v_80: G = (__v_65 + __v_79); let __v_81: G = (__v_63 + __v_80); let __v_82: G = (__v_28 + __v_81); - let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 4] = [__v_40, __v_61, __v_82, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_130] = [__v_83, __v_39]; - record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[130].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12714,26 +12846,27 @@ const INPUT_SIZE_131: usize = 5; const IN_131: usize = 5; const OUT_131: usize = 1; fn aiur_fn_131( - inp: [G; IN_131], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(131); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_131] = [__v_5]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, 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); @@ -12742,7 +12875,7 @@ fn aiur_fn_131( 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_131] = [__v_9]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12750,10 +12883,10 @@ fn aiur_fn_131( 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_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[131].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i)?; } record.function_queries[131].output_at(__i).to_array::() }, _ => aiur_fn_131(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_131] = [__v_13]; - record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[131].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12766,37 +12899,38 @@ const INPUT_SIZE_132: usize = 4; const IN_132: usize = 4; const OUT_132: usize = 1; fn aiur_fn_132( - inp: [G; IN_132], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(132); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_132] = [__v_6]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[131].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i)?; } record.function_queries[131].output_at(__i).to_array::() }, _ => aiur_fn_131(__key, 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_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_132] = [__v_8]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -12807,11 +12941,11 @@ fn aiur_fn_132( 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_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_132] = [__v_14]; - record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[132].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12824,21 +12958,22 @@ const INPUT_SIZE_133: usize = 8; const IN_133: usize = 8; const OUT_133: usize = 1; fn aiur_fn_133( - inp: [G; IN_133], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(133); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -12850,9 +12985,9 @@ fn aiur_fn_133( 1u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); - let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_133] = [__v_17]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12864,7 +12999,7 @@ fn aiur_fn_133( 1u64 => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_3, __v_6, __v_7, __v_17, __v_18, __v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[123].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i)?; } record.function_queries[123].output_at(__i).to_array::() }, _ => aiur_fn_123(__key, 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]; @@ -12880,18 +13015,18 @@ fn aiur_fn_133( let __v_31: G = (__v_12 + __v_27); let __v_32: G = (__v_13 + __v_30); let __v_33: G = G::from_u64(0); - let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 7] = [__v_33, __v_9, __v_21, __v_22, __v_31, __v_32, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_133] = [__v_34]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_133] = [__v_19]; - record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[133].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12909,15 +13044,16 @@ const INPUT_SIZE_134: usize = 2; const IN_134: usize = 2; const OUT_134: usize = 1; fn aiur_fn_134( - inp: [G; IN_134], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(134); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -12929,7 +13065,7 @@ fn aiur_fn_134( 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_134] = [__v_9]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -12952,14 +13088,14 @@ fn aiur_fn_134( } let __v_19: G = G::from_u64(1); let __ret: [G; OUT_134] = [__v_19]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_8, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_134] = [__v_11]; - record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[134].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -12977,25 +13113,26 @@ const INPUT_SIZE_135: usize = 2; const IN_135: usize = 2; const OUT_135: usize = 1; fn aiur_fn_135( - inp: [G; IN_135], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(135); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); let __ret: [G; OUT_135] = [__v_2]; - record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[135].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); let __ret: [G; OUT_135] = [__v_2]; - record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[135].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13009,34 +13146,35 @@ const INPUT_SIZE_136: usize = 10; const IN_136: usize = 10; const OUT_136: usize = 1; fn aiur_fn_136( - inp: [G; IN_136], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; + record.checkpoint(136); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; let __v_10: G = (__v_3 - __v_1); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); - let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_11, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_11, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_13, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[120].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i)?; } record.function_queries[120].output_at(__i).to_array::() }, _ => aiur_fn_120(__key, 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); @@ -13065,9 +13203,9 @@ fn aiur_fn_136( let __v_37: G = G::from_u64(0); let __v_38: G = (__v_37 - __v_22); let __v_39: G = (__v_38 * __v_28); - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, 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)); @@ -13075,10 +13213,10 @@ fn aiur_fn_136( 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_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_6, __v_7, __v_36, __v_39, __v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[133].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i)?; } record.function_queries[133].output_at(__i).to_array::() }, _ => aiur_fn_133(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __ret: [G; OUT_136] = [__v_45]; - record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[136].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13087,30 +13225,31 @@ const INPUT_SIZE_137: usize = 11; const IN_137: usize = 11; const OUT_137: usize = 1; fn aiur_fn_137( - inp: [G; IN_137], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - 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]; + record.checkpoint(137); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -13121,12 +13260,12 @@ fn aiur_fn_137( 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_136] = { let __args: [G; IN_136] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_25, __v_3, __v_1, __v_2, __v_21, __v_24, __v_7, __v_14, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __ret: [G; OUT_137] = [__v_26]; - record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[137].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13135,49 +13274,50 @@ const INPUT_SIZE_138: usize = 13; const IN_138: usize = 13; const OUT_138: usize = 1; fn aiur_fn_138( - inp: [G; IN_138], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(138); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_138] = [__v_0]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[138].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_15, __v_16, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, 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_138] = { let __args: [G; IN_138] = [__v_17, __v_1, __v_2, __v_3, __v_19, __v_21, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __ret: [G; OUT_138] = [__v_22]; - record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[138].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13188,52 +13328,53 @@ const INPUT_SIZE_139: usize = 13; const IN_139: usize = 13; const OUT_139: usize = 1; fn aiur_fn_139( - inp: [G; IN_139], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - 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]; + record.checkpoint(139); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_139] = [__v_0]; - record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[139].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_9, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_15, __v_18, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[136].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i)?; } record.function_queries[136].output_at(__i).to_array::() }, _ => aiur_fn_136(__key, 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_139] = { let __args: [G; IN_139] = [__v_19, __v_1, __v_2, __v_3, __v_21, __v_23, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[139].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i)?; } record.function_queries[139].output_at(__i).to_array::() }, _ => aiur_fn_139(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __ret: [G; OUT_139] = [__v_24]; - record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[139].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13244,35 +13385,36 @@ const INPUT_SIZE_140: usize = 15; const IN_140: usize = 15; const OUT_140: usize = 1; fn aiur_fn_140( - inp: [G; IN_140], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - 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]; + record.checkpoint(140); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_140] = [__v_0]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -13281,21 +13423,21 @@ fn aiur_fn_140( 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_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_21]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_19, __v_20, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[137].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i)?; } record.function_queries[137].output_at(__i).to_array::() }, _ => aiur_fn_137(__key, 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); @@ -13303,10 +13445,10 @@ fn aiur_fn_140( 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_140] = { let __args: [G; IN_140] = [__v_21, __v_1, __v_2, __v_3, __v_23, __v_25, __v_27, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __ret: [G; OUT_140] = [__v_28]; - record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[140].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13322,47 +13464,48 @@ const INPUT_SIZE_141: usize = 15; const IN_141: usize = 15; const OUT_141: usize = 1; fn aiur_fn_141( - inp: [G; IN_141], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __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]; + record.checkpoint(141); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_141] = [__v_0]; - record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[141].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_6, __v_10, __v_5, __v_7, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_20 - __v_21); let __v_23: G = G::from_bool((__v_22 == G::ZERO)); @@ -13372,10 +13515,10 @@ fn aiur_fn_141( } let __v_25: G = G::from_u64(0); let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_8, __v_9, __v_10, __v_25, __v_7, __v_26, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[140].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i)?; } record.function_queries[140].output_at(__i).to_array::() }, _ => aiur_fn_140(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __ret: [G; OUT_141] = [__v_27]; - record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[141].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13391,39 +13534,40 @@ const INPUT_SIZE_142: usize = 4; const IN_142: usize = 4; const OUT_142: usize = 1; fn aiur_fn_142( - inp: [G; IN_142], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(142); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_142] = [__v_6]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[142].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, 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_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_1, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_142] = [__v_12]; - record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[142].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13434,14 +13578,15 @@ const INPUT_SIZE_143: usize = 1; const IN_143: usize = 1; const OUT_143: usize = 1; fn aiur_fn_143( - inp: [G; IN_143], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(143); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -13449,22 +13594,22 @@ fn aiur_fn_143( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_143] = [__v_4]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, 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 }; + 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_143] = [__v_4]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_143] = [__v_2]; - record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[143].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13480,28 +13625,29 @@ const INPUT_SIZE_144: usize = 5; const IN_144: usize = 5; const OUT_144: usize = 1; fn aiur_fn_144( - inp: [G; IN_144], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(144); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_144] = [__v_7]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -13510,26 +13656,26 @@ fn aiur_fn_144( 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_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __ret: [G; OUT_144] = [__v_11]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, 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_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_144] = [__v_15]; - record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[144].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -13545,26 +13691,27 @@ const INPUT_SIZE_145: usize = 5; const IN_145: usize = 5; const OUT_145: usize = 4; fn aiur_fn_145( - inp: [G; IN_145], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; + record.checkpoint(145); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; match __v_0.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_145] = [__v_1, __v_2, __v_3, __v_4]; - record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_145] = [__v_3, __v_4, __v_1, __v_2]; - record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[145].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13575,16 +13722,17 @@ const INPUT_SIZE_146: usize = 4; const IN_146: usize = 4; const OUT_146: usize = 1; fn aiur_fn_146( - inp: [G; IN_146], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(146); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); let __v_4: G = G::from_u8(__gb[0]); let __v_5: G = G::from_u8(__gb[1]); @@ -13594,10 +13742,10 @@ fn aiur_fn_146( let __v_9: G = G::from_u8(__gb[5]); let __v_10: G = G::from_u8(__gb[6]); let __v_11: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_4; let __vj = __v_5; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_6; let __vj = __v_7; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_8; let __vj = __v_9; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_10; let __vj = __v_11; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_4; let __vj = __v_5; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_6; let __vj = __v_7; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_8; let __vj = __v_9; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_10; let __vj = __v_11; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_12: G = G::from_u64(1020); let __v_13: G = (__v_11 - __v_12); let __v_14: G = (__v_10 + __v_13); @@ -13617,10 +13765,10 @@ fn aiur_fn_146( let __v_27: G = G::from_u8(__gb[5]); let __v_28: G = G::from_u8(__gb[6]); let __v_29: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_22; let __vj = __v_23; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_24; let __vj = __v_25; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_26; let __vj = __v_27; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_28; let __vj = __v_29; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_22; let __vj = __v_23; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_24; let __vj = __v_25; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_26; let __vj = __v_27; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_28; let __vj = __v_29; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_30: G = G::from_u64(1020); let __v_31: G = (__v_29 - __v_30); let __v_32: G = (__v_28 + __v_31); @@ -13640,10 +13788,10 @@ fn aiur_fn_146( let __v_45: G = G::from_u8(__gb[5]); let __v_46: G = G::from_u8(__gb[6]); let __v_47: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_44; let __vj = __v_45; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_46; let __vj = __v_47; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_48: G = G::from_u64(1020); let __v_49: G = (__v_47 - __v_48); let __v_50: G = (__v_46 + __v_49); @@ -13663,10 +13811,10 @@ fn aiur_fn_146( let __v_63: G = G::from_u8(__gb[5]); let __v_64: G = G::from_u8(__gb[6]); let __v_65: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_66: G = G::from_u64(1020); let __v_67: G = (__v_65 - __v_66); let __v_68: G = (__v_64 + __v_67); @@ -13815,13 +13963,13 @@ fn aiur_fn_146( } let __v_188: G = G::from_u64(1); let __v_189: G = G::from_u64(1); - let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_193: G = { let __values: [G; 10] = [__v_104, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_192]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_194: G = { let __values: [G; 10] = [__v_76, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_193]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_190: G = { let __values: [G; 10] = [__v_188, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189, __v_189]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_191: G = { let __values: [G; 10] = [__v_160, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_190]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_192: G = { let __values: [G; 10] = [__v_132, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_191]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_146] = [__v_194]; - record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[146].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -13830,19 +13978,20 @@ const INPUT_SIZE_147: usize = 6; const IN_147: usize = 6; const OUT_147: usize = 3; fn aiur_fn_147( - inp: [G; IN_147], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(147); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -13853,7 +14002,7 @@ fn aiur_fn_147( match __v_6.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_147] = [__v_0, __v_1, __v_5]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -13864,7 +14013,7 @@ fn aiur_fn_147( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_3, __v_4, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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); @@ -13878,12 +14027,12 @@ fn aiur_fn_147( let __v_26: G = (__v_0 + __v_22); let __v_27: G = (__v_1 + __v_25); let __ret: [G; OUT_147] = [__v_26, __v_27, __v_12]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __ret: [G; OUT_147] = [__v_0, __v_1, __v_5]; - record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[147].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -13901,22 +14050,23 @@ const INPUT_SIZE_148: usize = 9; const IN_148: usize = 9; const OUT_148: usize = 3; fn aiur_fn_148( - inp: [G; IN_148], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(148); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -13929,7 +14079,7 @@ fn aiur_fn_148( if (__v_14 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); if (__v_16 != __v_17) { @@ -13937,20 +14087,20 @@ fn aiur_fn_148( } let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); - let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_148] = [__v_0, __v_1, __v_20]; - record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[148].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; let __v_16: G = __loaded[3]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; @@ -13958,7 +14108,7 @@ fn aiur_fn_148( 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -13967,7 +14117,7 @@ fn aiur_fn_148( let __v_23: G = G::from_u64(1); let __v_24: G = (__v_6 - __v_23); let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_11, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_11, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_21.as_canonical_u64() { @@ -13983,14 +14133,14 @@ fn aiur_fn_148( let __v_29: G = __mc_out___mc_0[1]; let __v_30: G = __mc_out___mc_0[2]; let __v_31: G = __mc_out___mc_0[3]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_22, __v_24, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[121].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i)?; } record.function_queries[121].output_at(__i).to_array::() }, _ => aiur_fn_121(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_32, __v_33, __v_24, __v_14, __v_15, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[147].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i)?; } record.function_queries[147].output_at(__i).to_array::() }, _ => aiur_fn_147(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_34, __v_35, __v_16, __v_19, __v_12, __v_22, __v_24, __v_36, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[148].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i)?; } record.function_queries[148].output_at(__i).to_array::() }, _ => aiur_fn_148(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -14003,10 +14153,10 @@ fn aiur_fn_148( let __v_45: G = G::from_u8(__gb[5]); let __v_46: G = G::from_u8(__gb[6]); let __v_47: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_40; let __vj = __v_41; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_42; let __vj = __v_43; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_44; let __vj = __v_45; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_46; let __vj = __v_47; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_40; let __vj = __v_41; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_42; let __vj = __v_43; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_44; let __vj = __v_45; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_46; let __vj = __v_47; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_48: G = G::from_u64(1020); let __v_49: G = (__v_47 - __v_48); let __v_50: G = (__v_46 + __v_49); @@ -14026,10 +14176,10 @@ fn aiur_fn_148( let __v_63: G = G::from_u8(__gb[5]); let __v_64: G = G::from_u8(__gb[6]); let __v_65: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_58; let __vj = __v_59; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_60; let __vj = __v_61; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_62; let __vj = __v_63; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_64; let __vj = __v_65; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_58; let __vj = __v_59; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_60; let __vj = __v_61; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_62; let __vj = __v_63; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_64; let __vj = __v_65; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_66: G = G::from_u64(1020); let __v_67: G = (__v_65 - __v_66); let __v_68: G = (__v_64 + __v_67); @@ -14049,10 +14199,10 @@ fn aiur_fn_148( let __v_81: G = G::from_u8(__gb[5]); let __v_82: G = G::from_u8(__gb[6]); let __v_83: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_76; let __vj = __v_77; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_78; let __vj = __v_79; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_80; let __vj = __v_81; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_82; let __vj = __v_83; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_76; let __vj = __v_77; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_78; let __vj = __v_79; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_80; let __vj = __v_81; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_82; let __vj = __v_83; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_84: G = G::from_u64(1020); let __v_85: G = (__v_83 - __v_84); let __v_86: G = (__v_82 + __v_85); @@ -14072,10 +14222,10 @@ fn aiur_fn_148( let __v_99: G = G::from_u8(__gb[5]); let __v_100: G = G::from_u8(__gb[6]); let __v_101: G = G::from_u8(__gb[7]); - if !unconstrained { let __vi = __v_94; let __vj = __v_95; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_96; let __vj = __v_97; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_98; let __vj = __v_99; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; - if !unconstrained { let __vi = __v_100; let __vj = __v_101; let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64(); if __bi >= 256 { return Err(ExecError::U8RangeCheckFailed(__bi)); } if __bj >= 256 { return Err(ExecError::U8RangeCheckFailed(__bj)); } record.bytes2_queries.bump_range_check(&__vi, &__vj); }; + if !unconstrained { let __vi = __v_94; let __vj = __v_95; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_96; let __vj = __v_97; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_98; let __vj = __v_99; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; + if !unconstrained { let __vi = __v_100; let __vj = __v_101; record.bytes2_queries.bump_range_check(&__vi, &__vj)?; }; let __v_102: G = G::from_u64(1020); let __v_103: G = (__v_101 - __v_102); let __v_104: G = (__v_100 + __v_103); @@ -14086,7 +14236,7 @@ fn aiur_fn_148( let __v_109: G = (__v_95 + __v_108); let __v_110: G = (__v_94 + __v_109); let __v_111: G = G::from_bool((__v_110 == G::ZERO)); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = G::from_u64(1); if (__v_112 != __v_113) { @@ -14231,14 +14381,14 @@ fn aiur_fn_148( } let __v_227: G = G::from_u64(1); let __v_228: G = G::from_u64(1); - let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_229: G = { let __values: [G; 10] = [__v_227, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228, __v_228]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_230: G = { let __values: [G; 10] = [__v_199, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_229]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_231: G = { let __values: [G; 10] = [__v_171, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_230]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_232: G = { let __values: [G; 10] = [__v_143, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_231]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_233: G = { let __values: [G; 10] = [__v_115, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_232]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_234: G = { let __values: [G; 3] = [__v_114, __v_233, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_148] = [__v_37, __v_38, __v_234]; - record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[148].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14269,73 +14419,74 @@ const INPUT_SIZE_149: usize = 25; const IN_149: usize = 25; const OUT_149: usize = 1; fn aiur_fn_149( - inp: [G; IN_149], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; + record.checkpoint(149); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_19, __v_18, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[132].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i)?; } record.function_queries[132].output_at(__i).to_array::() }, _ => aiur_fn_132(__key, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_15, __v_19, __v_18, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; match __v_29.as_canonical_u64() { _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_25, __v_0, __v_20, __v_19, __v_30, __v_18, __v_15, __v_16, __v_17, __v_29, __v_5, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_33.as_canonical_u64() { _ => { let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_31, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_33, __v_6, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[138].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i)?; } record.function_queries[138].output_at(__i).to_array::() }, _ => aiur_fn_138(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; match __v_37.as_canonical_u64() { _ => { let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_35, __v_0, __v_20, __v_19, __v_38, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[139].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i)?; } record.function_queries[139].output_at(__i).to_array::() }, _ => aiur_fn_139(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_39, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[141].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i)?; } record.function_queries[141].output_at(__i).to_array::() }, _ => aiur_fn_141(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_40, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_40, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[134].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i)?; } record.function_queries[134].output_at(__i).to_array::() }, _ => aiur_fn_134(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_42: G = __loaded[0]; let __v_43: G = __loaded[1]; let __v_44: G = __loaded[2]; @@ -14347,15 +14498,15 @@ fn aiur_fn_149( 0u64 => { match __v_43.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_46, __v_47, __v_21, __v_22, __v_2, __v_0, __v_20, __v_48, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[148].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i)?; } record.function_queries[148].output_at(__i).to_array::() }, _ => aiur_fn_148(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_23, __v_52]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = (__v_55 - __v_24); let __v_57: G = G::from_bool((__v_56 == G::ZERO)); @@ -14363,10 +14514,10 @@ fn aiur_fn_149( if (__v_57 != __v_58) { return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = (__v_60 + __v_61); let __v_63: G = (__v_59 - __v_62); @@ -14375,7 +14526,7 @@ fn aiur_fn_149( if (__v_64 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = (__v_66 - __v_18); let __v_68: G = G::from_bool((__v_67 == G::ZERO)); @@ -14383,7 +14534,7 @@ fn aiur_fn_149( if (__v_68 != __v_69) { return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_69.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = (__v_70 - __v_18); let __v_72: G = G::from_bool((__v_71 == G::ZERO)); @@ -14391,7 +14542,7 @@ fn aiur_fn_149( if (__v_72 != __v_73) { return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, 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)); @@ -14415,7 +14566,7 @@ fn aiur_fn_149( return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_86.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_149] = [__v_51]; - record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[149].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14439,38 +14590,39 @@ const INPUT_SIZE_150: usize = 25; const IN_150: usize = 25; const OUT_150: usize = 1; fn aiur_fn_150( - inp: [G; IN_150], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(150); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; @@ -14479,24 +14631,24 @@ fn aiur_fn_150( 1u64 => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); - let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_150] = [__v_31]; - record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[150].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, 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_149] = { let __args: [G; IN_149] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[149].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i)?; } record.function_queries[149].output_at(__i).to_array::() }, _ => aiur_fn_149(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_32, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_150] = [__v_35]; - record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[150].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14510,38 +14662,39 @@ const INPUT_SIZE_151: usize = 4; const IN_151: usize = 4; const OUT_151: usize = 1; fn aiur_fn_151( - inp: [G; IN_151], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(151); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_151] = [__v_6]; - record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[151].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[170].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i)?; } record.function_queries[170].output_at(__i).to_array::() }, _ => aiur_fn_170(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5, __v_6, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_5, __v_6, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_4, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_151] = [__v_11]; - record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[151].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14552,15 +14705,16 @@ const INPUT_SIZE_152: usize = 2; const IN_152: usize = 2; const OUT_152: usize = 1; fn aiur_fn_152( - inp: [G; IN_152], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(152); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14569,22 +14723,22 @@ fn aiur_fn_152( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_152] = [__v_8]; - record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[152].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_5, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_152] = [__v_9]; - record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[152].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14600,15 +14754,16 @@ const INPUT_SIZE_153: usize = 2; const IN_153: usize = 2; const OUT_153: usize = 1; fn aiur_fn_153( - inp: [G; IN_153], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(153); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14618,22 +14773,22 @@ fn aiur_fn_153( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_153] = [__v_9]; - record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[153].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_3.as_canonical_u64() { _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_3, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_153] = [__v_10]; - record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[153].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14649,40 +14804,41 @@ const INPUT_SIZE_154: usize = 4; const IN_154: usize = 4; const OUT_154: usize = 1; fn aiur_fn_154( - inp: [G; IN_154], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(154); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_154] = [__v_6]; - record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[154].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[152].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i)?; } record.function_queries[152].output_at(__i).to_array::() }, _ => aiur_fn_152(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[153].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i)?; } record.function_queries[153].output_at(__i).to_array::() }, _ => aiur_fn_153(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1, __v_8, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_154] = [__v_12]; - record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[154].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14693,59 +14849,60 @@ const INPUT_SIZE_155: usize = 13; const IN_155: usize = 13; const OUT_155: usize = 1; fn aiur_fn_155( - inp: [G; IN_155], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(155); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_9, __v_11, __v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_9, __v_11, __v_10, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[142].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i)?; } record.function_queries[142].output_at(__i).to_array::() }, _ => aiur_fn_142(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { _ => { let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { _ => { let __v_21: G = G::from_u64(2); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_16, __v_14, __v_1, __v_17, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_3, __v_19, __v_14, __v_1, __v_20, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); if (__v_26 != __v_27) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_4, __v_22, __v_14, __v_1, __v_23, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { @@ -14755,28 +14912,28 @@ fn aiur_fn_155( 0u64 => { let __v_30: G = G::from_u64(1); let __ret: [G; OUT_155] = [__v_30]; - record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[155].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_30: G = G::from_u64(3); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; match __v_31.as_canonical_u64() { _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_9, __v_11, __v_8, __v_10, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[144].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i)?; } record.function_queries[144].output_at(__i).to_array::() }, _ => aiur_fn_144(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[143].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i)?; } record.function_queries[143].output_at(__i).to_array::() }, _ => aiur_fn_143(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_12 - __v_35); - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_1, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_1, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_5, __v_31, __v_34, __v_37, __v_32, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __ret: [G; OUT_155] = [__v_38]; - record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[155].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14798,33 +14955,34 @@ const INPUT_SIZE_156: usize = 2; const IN_156: usize = 2; const OUT_156: usize = 1; fn aiur_fn_156( - inp: [G; IN_156], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(156); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_156] = [__v_0]; - record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[156].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_156] = [__v_8]; - record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[156].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14838,15 +14996,16 @@ const INPUT_SIZE_157: usize = 2; const IN_157: usize = 2; const OUT_157: usize = 1; fn aiur_fn_157( - inp: [G; IN_157], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(157); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -14854,25 +15013,25 @@ fn aiur_fn_157( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_157] = [__v_7]; - record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[157].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[157].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i)?; } record.function_queries[157].output_at(__i).to_array::() }, _ => aiur_fn_157(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_5, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_157] = [__v_13]; - record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[157].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -14886,19 +15045,20 @@ const INPUT_SIZE_158: usize = 6; const IN_158: usize = 6; const OUT_158: usize = 1; fn aiur_fn_158( - inp: [G; IN_158], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(158); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -14906,15 +15066,15 @@ fn aiur_fn_158( let __v_10: G = __loaded[4]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_bool((__v_11 == G::ZERO)); let __ret: [G; OUT_158] = [__v_12]; - record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[158].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; @@ -14923,7 +15083,7 @@ fn aiur_fn_158( match __v_7.as_canonical_u64() { _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_3, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_3, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[156].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i)?; } record.function_queries[156].output_at(__i).to_array::() }, _ => aiur_fn_156(__key, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 - __v_16); @@ -14931,21 +15091,21 @@ fn aiur_fn_158( if (__v_7 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; if (__v_19 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_2, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[157].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i)?; } record.function_queries[157].output_at(__i).to_array::() }, _ => aiur_fn_157(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); - let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_26: G = { let __values: [G; 3] = [__v_22, __v_17, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12, __v_21, __v_26, __v_15, __v_9, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[118].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i)?; } record.function_queries[118].output_at(__i).to_array::() }, _ => aiur_fn_118(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); if (__v_27 != __v_28) { @@ -14953,10 +15113,10 @@ fn aiur_fn_158( } let __v_29: G = G::from_u64(1); let __v_30: G = (__v_4 + __v_29); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_10, __v_13, __v_2, __v_15, __v_30, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __ret: [G; OUT_158] = [__v_31]; - record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[158].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -14977,57 +15137,58 @@ const INPUT_SIZE_159: usize = 32; const IN_159: usize = 32; const OUT_159: usize = 1; fn aiur_fn_159( - inp: [G; IN_159], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; + record.checkpoint(159); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); - let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_4.as_canonical_u64() { 0u64 => { break '__mc_0 [__v_35]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; break '__mc_0 [__v_36]; }, @@ -15037,18 +15198,18 @@ fn aiur_fn_159( } }; let __v_36: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_2, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_2, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_1, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = G::from_u64(1); - let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_40, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -15109,30 +15270,30 @@ fn aiur_fn_159( let __v_101: G = (__v_86 + __v_100); let __v_102: G = (__v_84 + __v_101); let __v_103: G = (__v_52 + __v_102); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_60, __v_6, __v_7, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_60, __v_6, __v_7, __v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __v_106: G = G::from_u64(1); let __v_107: G = G::from_u64(1); - let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10, __v_108]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_108: G = { let __values: [G; 3] = [__v_106, __v_107, __v_107]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_10, __v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_105, __v_109]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_105, __v_109]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_110, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_110, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_111, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; let __v_113: G = __r_arr[1]; let __v_114: G = (__v_32 + __v_28); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_112, __v_113, __v_29, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_112, __v_113, __v_29, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_9, __v_116, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_8, __v_9, __v_116, __v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_112, __v_113, __v_117, __v_82, __v_103, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_114, __v_104, __v_6, __v_10, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = (__v_119 - __v_32); let __v_121: G = G::from_bool((__v_120 == G::ZERO)); @@ -15140,16 +15301,16 @@ fn aiur_fn_159( if (__v_121 != __v_122) { return Err(ExecError::AssertEqMismatch { lhs: __v_121.as_canonical_u64(), rhs: __v_122.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = (__v_124 + __v_125); if (__v_123 != __v_126) { return Err(ExecError::AssertEqMismatch { lhs: __v_123.as_canonical_u64(), rhs: __v_126.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = (__v_127 - __v_32); let __v_129: G = G::from_bool((__v_128 == G::ZERO)); @@ -15157,29 +15318,29 @@ fn aiur_fn_159( if (__v_129 != __v_130) { return Err(ExecError::AssertEqMismatch { lhs: __v_129.as_canonical_u64(), rhs: __v_130.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = G::from_u64(1); if (__v_131 != __v_132) { return Err(ExecError::AssertEqMismatch { lhs: __v_131.as_canonical_u64(), rhs: __v_132.as_canonical_u64(), msg: None }); } let __v_133: G = G::from_u64(33); - let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_134: G = { let __a_val = __v_114.as_canonical_u64(); let __b_val = __v_133.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_135: G = G::from_u64(1); if (__v_134 != __v_135) { return Err(ExecError::AssertEqMismatch { lhs: __v_134.as_canonical_u64(), rhs: __v_135.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_8, __v_115, __v_19, __v_20, __v_21, __v_22, __v_4, __v_5, __v_23, __v_24, __v_27, __v_28, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_136: G = __r_arr[0]; let __v_137: G = G::from_u64(1); if (__v_136 != __v_137) { return Err(ExecError::AssertEqMismatch { lhs: __v_136.as_canonical_u64(), rhs: __v_137.as_canonical_u64(), msg: None }); } let __v_138: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_9, __v_6, __v_118, __v_115, __v_138, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; let __ret: [G; OUT_159] = [__v_139]; - record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[159].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15190,19 +15351,20 @@ const INPUT_SIZE_160: usize = 2; const IN_160: usize = 2; const OUT_160: usize = 1; fn aiur_fn_160( - inp: [G; IN_160], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(160); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[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_160] = [__v_4]; - record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[160].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15211,14 +15373,15 @@ const INPUT_SIZE_161: usize = 1; const IN_161: usize = 1; const OUT_161: usize = 1; fn aiur_fn_161( - inp: [G; IN_161], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(161); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -15227,11 +15390,11 @@ fn aiur_fn_161( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_161] = [__v_5]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -15242,14 +15405,14 @@ fn aiur_fn_161( let __v_10: G = G::from_bool((__v_3 == G::ZERO)); let __v_11: G = (__v_9 * __v_10); let __ret: [G; OUT_161] = [__v_11]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_161] = [__v_9]; - record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[161].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15265,21 +15428,22 @@ const INPUT_SIZE_162: usize = 9; const IN_162: usize = 9; const OUT_162: usize = 1; fn aiur_fn_162( - inp: [G; IN_162], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(162); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); @@ -15288,16 +15452,16 @@ fn aiur_fn_162( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_6, __v_17]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_14, __v_5, __v_18]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_13, __v_4, __v_19]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_21: G = { let __values: [G; 3] = [__v_12, __v_3, __v_20]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_162] = [__v_24]; - record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[162].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15306,55 +15470,56 @@ const INPUT_SIZE_163: usize = 33; const IN_163: usize = 33; const OUT_163: usize = 1; fn aiur_fn_163( - inp: [G; IN_163], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + record.checkpoint(163); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __ret: [G; OUT_163] = [__v_36]; - record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[163].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15363,26 +15528,27 @@ const INPUT_SIZE_164: usize = 2; const IN_164: usize = 2; const OUT_164: usize = 1; fn aiur_fn_164( - inp: [G; IN_164], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(164); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_164] = [__v_1]; - record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[164].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -15415,18 +15581,18 @@ fn aiur_fn_164( let __v_34: G = __loaded[29]; let __v_35: G = __loaded[30]; let __v_36: G = __loaded[31]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __ret: [G; OUT_164] = [__v_41]; - record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[164].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15440,22 +15606,23 @@ const INPUT_SIZE_165: usize = 2; const IN_165: usize = 2; const OUT_165: usize = 1; fn aiur_fn_165( - inp: [G; IN_165], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(165); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_165] = [__v_1]; - record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[165].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -15466,12 +15633,12 @@ fn aiur_fn_165( 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_165] = { let __args: [G; IN_165] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_165] = [__v_13]; - record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[165].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15485,15 +15652,16 @@ const INPUT_SIZE_166: usize = 2; const IN_166: usize = 2; const OUT_166: usize = 10; fn aiur_fn_166( - inp: [G; IN_166], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(166); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -15533,7 +15701,7 @@ fn aiur_fn_166( let __v_36: G = G::from_u64(91); let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); - let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); @@ -15544,14 +15712,14 @@ fn aiur_fn_166( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = { let __values: [G; 8] = [__v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_51: G = { let __values: [G; 32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); - let __v_54: G = { let __values: [G; 34] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_0, __v_39, __v_40, __v_41, __v_50, __v_51, __v_54]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -15586,78 +15754,78 @@ fn aiur_fn_166( let __v_87: G = __r_arr[31]; let __v_88: G = G::from_u64(1); let __v_89: G = G::from_u64(1); - let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_84, __v_85, __v_86, __v_87, __v_90]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_80, __v_81, __v_82, __v_83, __v_91]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_76, __v_77, __v_78, __v_79, __v_92]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_72, __v_73, __v_74, __v_75, __v_93]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_94: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_68, __v_69, __v_70, __v_71, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_64, __v_65, __v_66, __v_67, __v_95]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_60, __v_61, __v_62, __v_63, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[98].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i); } let __ret: [G; OUT_98] = unsafe { *(record.function_queries[98].output_at(__i).as_ptr() as *const [G; OUT_98]) }; __ret }, _ => aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_56, __v_57, __v_58, __v_59, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[98].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[98].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[98].bump_multiplicity(__i)?; } record.function_queries[98].output_at(__i).to_array::() }, _ => aiur_fn_98(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = G::from_u64(1); let __v_100: G = G::from_u64(1); - let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_98, __v_101]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_101: G = { let __values: [G; 3] = [__v_99, __v_100, __v_100]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_98, __v_101]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[119].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i)?; } record.function_queries[119].output_at(__i).to_array::() }, _ => aiur_fn_119(__key, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_103: G = __loaded[0]; let __v_104: G = __loaded[1]; let __v_105: G = __loaded[2]; match __v_103.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_106: G = __loaded[0]; let __v_107: G = __loaded[1]; let __v_108: G = __loaded[2]; match __v_106.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_109: G = __loaded[0]; let __v_110: G = __loaded[1]; let __v_111: G = __loaded[2]; match __v_109.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_112: G = __loaded[0]; let __v_113: G = __loaded[1]; let __v_114: G = __loaded[2]; match __v_112.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_115: G = __loaded[0]; let __v_116: G = __loaded[1]; let __v_117: G = __loaded[2]; match __v_115.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_118: G = __loaded[0]; let __v_119: G = __loaded[1]; let __v_120: G = __loaded[2]; match __v_118.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_121: G = __loaded[0]; let __v_122: G = __loaded[1]; let __v_123: G = __loaded[2]; match __v_121.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_124: G = __loaded[0]; let __v_125: G = __loaded[1]; let __v_126: G = __loaded[2]; match __v_124.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_166] = [__v_104, __v_107, __v_110, __v_113, __v_116, __v_119, __v_122, __v_125, __v_98, __v_126]; - record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[166].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15701,50 +15869,50 @@ fn aiur_fn_166( } }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_11: G = __loaded[0]; let __v_12: G = __loaded[1]; let __v_13: G = __loaded[2]; match __v_11.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_14: G = __loaded[0]; let __v_15: G = __loaded[1]; let __v_16: G = __loaded[2]; match __v_14.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_17: G = __loaded[0]; let __v_18: G = __loaded[1]; let __v_19: G = __loaded[2]; match __v_17.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; match __v_20.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_23: G = __loaded[0]; let __v_24: G = __loaded[1]; let __v_25: G = __loaded[2]; match __v_23.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_166] = [__v_3, __v_6, __v_9, __v_12, __v_15, __v_18, __v_21, __v_24, __v_0, __v_25]; - record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[166].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15793,15 +15961,16 @@ const INPUT_SIZE_167: usize = 2; const IN_167: usize = 2; const OUT_167: usize = 10; fn aiur_fn_167( - inp: [G; IN_167], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + record.checkpoint(167); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, 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]; @@ -15830,11 +15999,11 @@ fn aiur_fn_167( match __v_26.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_167] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[167].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, 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]; @@ -15846,7 +16015,7 @@ fn aiur_fn_167( let __v_35: G = __r_arr[8]; let __v_36: G = __r_arr[9]; let __ret: [G; OUT_167] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[167].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -15857,15 +16026,16 @@ const INPUT_SIZE_168: usize = 2; const IN_168: usize = 2; const OUT_168: usize = 18; fn aiur_fn_168( - inp: [G; IN_168], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + record.checkpoint(168); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, 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]; @@ -15876,7 +16046,7 @@ fn aiur_fn_168( 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_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_10, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[167].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i)?; } record.function_queries[167].output_at(__i).to_array::() }, _ => aiur_fn_167(__key, 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]; @@ -15888,7 +16058,7 @@ fn aiur_fn_168( let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; let __ret: [G; OUT_168] = [__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]; - record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[168].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -15897,25 +16067,26 @@ const INPUT_SIZE_169: usize = 2; const IN_169: usize = 2; const OUT_169: usize = 1; fn aiur_fn_169( - inp: [G; IN_169], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(169); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_169] = [__v_4]; - record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[169].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -15924,11 +16095,11 @@ fn aiur_fn_169( 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_169] = { let __args: [G; IN_169] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_169] = [__v_9]; - record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[169].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -15944,16 +16115,17 @@ const INPUT_SIZE_170: usize = 3; const IN_170: usize = 3; const OUT_170: usize = 3; fn aiur_fn_170( - inp: [G; IN_170], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } }; + record.checkpoint(170); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[166].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i)?; } record.function_queries[166].output_at(__i).to_array::() }, _ => aiur_fn_166(__key, 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]; @@ -15964,7 +16136,7 @@ fn aiur_fn_170( let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record)? }; let __v_13: G = __b1_out[0]; let __v_14: G = __b1_out[1]; let __v_15: G = __b1_out[2]; @@ -15973,7 +16145,7 @@ fn aiur_fn_170( let __v_18: G = __b1_out[5]; let __v_19: G = __b1_out[6]; let __v_20: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record)? }; let __v_21: G = __b1_out[0]; let __v_22: G = __b1_out[1]; let __v_23: G = __b1_out[2]; @@ -15982,7 +16154,7 @@ fn aiur_fn_170( let __v_26: G = __b1_out[5]; let __v_27: G = __b1_out[6]; let __v_28: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_5); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_5, record)? }; let __v_29: G = __b1_out[0]; let __v_30: G = __b1_out[1]; let __v_31: G = __b1_out[2]; @@ -15991,7 +16163,7 @@ fn aiur_fn_170( let __v_34: G = __b1_out[5]; let __v_35: G = __b1_out[6]; let __v_36: G = __b1_out[7]; - let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record) }; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_6); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_6, record)? }; let __v_37: G = __b1_out[0]; let __v_38: G = __b1_out[1]; let __v_39: G = __b1_out[2]; @@ -16002,19 +16174,19 @@ fn aiur_fn_170( let __v_44: G = __b1_out[7]; let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_51, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_51, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[169].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i)?; } record.function_queries[169].output_at(__i).to_array::() }, _ => aiur_fn_169(__key, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __ret: [G; OUT_170] = [__v_52, __v_11, __v_12]; - record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[170].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16023,30 +16195,31 @@ const INPUT_SIZE_171: usize = 9; const IN_171: usize = 9; const OUT_171: usize = 1; fn aiur_fn_171( - inp: [G; IN_171], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = 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]; + record.checkpoint(171); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_171] = [__v_13]; - record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[171].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16055,23 +16228,24 @@ const INPUT_SIZE_172: usize = 2; const IN_172: usize = 2; const OUT_172: usize = 1; fn aiur_fn_172( - inp: [G; IN_172], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(172); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __ret: [G; OUT_172] = [__v_6]; - record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[172].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16080,13 +16254,14 @@ const INPUT_SIZE_173: usize = 1; const IN_173: usize = 1; const OUT_173: usize = 1; fn aiur_fn_173( - inp: [G; IN_173], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(173); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(0); let __v_2: G = G::from_u64(109); let __v_3: G = G::from_u64(0); @@ -16115,22 +16290,22 @@ fn aiur_fn_173( let __v_26: G = G::from_u64(118); let __v_27: G = G::from_u64(0); let __v_28: G = G::from_u64(48); - let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_0]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_30: G = { let __values: [G; 3] = [__v_25, __v_26, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 3] = [__v_23, __v_24, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 3] = [__v_21, __v_22, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_33: G = { let __values: [G; 3] = [__v_19, __v_20, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_34: G = { let __values: [G; 3] = [__v_17, __v_18, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_15, __v_16, __v_34]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_36: G = { let __values: [G; 3] = [__v_13, __v_14, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_11, __v_12, __v_36]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_38: G = { let __values: [G; 3] = [__v_9, __v_10, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_7, __v_8, __v_38]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_173] = [__v_42]; - record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[173].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16139,15 +16314,16 @@ const INPUT_SIZE_174: usize = 2; const IN_174: usize = 2; const OUT_174: usize = 1; fn aiur_fn_174( - inp: [G; IN_174], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(174); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -16161,16 +16337,16 @@ fn aiur_fn_174( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_174] = [__v_1]; - record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[174].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_174] = [__v_13]; - record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[174].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16184,26 +16360,27 @@ const INPUT_SIZE_175: usize = 2; const IN_175: usize = 2; const OUT_175: usize = 1; fn aiur_fn_175( - inp: [G; IN_175], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(175); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_175] = [__v_4]; - record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[175].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __ret: [G; OUT_175] = [__v_1]; - record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[175].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16217,30 +16394,31 @@ const INPUT_SIZE_176: usize = 9; const IN_176: usize = 9; const OUT_176: usize = 9; fn aiur_fn_176( - inp: [G; IN_176], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + record.checkpoint(176); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_2, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, 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); @@ -16270,24 +16448,24 @@ fn aiur_fn_176( let __v_39: G = G::from_u64(118); let __v_40: G = G::from_u64(0); let __v_41: G = G::from_u64(48); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_38, __v_39, __v_42]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_36, __v_37, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_34, __v_35, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_46: G = { let __values: [G; 3] = [__v_32, __v_33, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_30, __v_31, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_28, __v_29, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_26, __v_27, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_50: G = { let __values: [G; 3] = [__v_24, __v_25, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_22, __v_23, __v_50]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_20, __v_21, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_18, __v_19, __v_52]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_54: G = { let __values: [G; 3] = [__v_16, __v_17, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_14, __v_15, __v_54]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); - let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_55, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_58: G = { let __values: [G; 3] = [__v_56, __v_57, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_55, __v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16308,17 +16486,17 @@ fn aiur_fn_176( let __v_76: G = __r_arr[17]; let __v_77: G = G::from_u64(1); let __v_78: G = G::from_u64(1); - let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_79: G = { let __values: [G; 3] = [__v_77, __v_78, __v_78]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_80]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_75, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_75, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); let __v_84: G = G::from_u64(1); - let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_82, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_85: G = { let __values: [G; 3] = [__v_83, __v_84, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_82, __v_85]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16339,26 +16517,26 @@ fn aiur_fn_176( let __v_103: G = __r_arr[17]; let __v_104: G = G::from_u64(1); let __v_105: G = G::from_u64(1); - let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_106: G = { let __values: [G; 3] = [__v_104, __v_105, __v_105]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_107]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_108: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_102, __v_108]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_102, __v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_109, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_109, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; let __v_111: G = G::from_u64(1); let __v_112: G = G::from_u64(1); - let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_8, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_113: G = { let __values: [G; 3] = [__v_111, __v_112, __v_112]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_8, __v_113]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_110, __v_114]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_110, __v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = G::from_u64(1); let __v_117: G = G::from_u64(1); - let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_115, __v_118]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_118: G = { let __values: [G; 3] = [__v_116, __v_117, __v_117]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_115, __v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16377,12 +16555,12 @@ fn aiur_fn_176( 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_172] = { let __args: [G; IN_172] = [__v_135, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_135, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = G::from_u64(1); let __v_139: G = G::from_u64(1); - let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_137, __v_140]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_140: G = { let __values: [G; 3] = [__v_138, __v_139, __v_139]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_137, __v_140]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -16570,7 +16748,7 @@ fn aiur_fn_176( let __v_325: G = (__v_307 + __v_324); let __v_326: G = (__v_149 + __v_325); let __ret: [G; OUT_176] = [__v_179, __v_200, __v_221, __v_242, __v_263, __v_284, __v_305, __v_326, __v_157]; - record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[176].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16579,19 +16757,20 @@ const INPUT_SIZE_177: usize = 3; const IN_177: usize = 3; const OUT_177: usize = 2; fn aiur_fn_177( - inp: [G; IN_177], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(177); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_2.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_177] = [__v_0, __v_1]; - record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[177].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -16605,11 +16784,11 @@ fn aiur_fn_177( 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_177] = { let __args: [G; IN_177] = [__v_7, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_7, __v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_177] = [__v_13, __v_14]; - record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[177].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16620,34 +16799,35 @@ const INPUT_SIZE_178: usize = 1; const IN_178: usize = 1; const OUT_178: usize = 1; fn aiur_fn_178( - inp: [G; IN_178], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(178); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_178] = [__v_1]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 32u64 => { let __v_1: G = G::from_u64(1753635133440165772); let __ret: [G; OUT_178] = [__v_1]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !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_178] = { let __args: [G; IN_178] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_3 * __v_3); let __ret: [G; OUT_178] = [__v_4]; - record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[178].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16658,16 +16838,17 @@ const INPUT_SIZE_179: usize = 3; const IN_179: usize = 3; const OUT_179: usize = 2; fn aiur_fn_179( - inp: [G; IN_179], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + record.checkpoint(179); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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); @@ -16675,7 +16856,7 @@ fn aiur_fn_179( let __v_7: G = (__v_3 - __v_5); let __v_8: G = (__v_4 - __v_6); let __ret: [G; OUT_179] = [__v_7, __v_8]; - record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[179].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16684,29 +16865,30 @@ const INPUT_SIZE_180: usize = 1; const IN_180: usize = 1; const OUT_180: usize = 1; fn aiur_fn_180( - inp: [G; IN_180], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; + record.checkpoint(180); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_180] = [__v_1]; - record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[180].finish_prehashed(&inp, &__ret[..], !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_180] = { let __args: [G; IN_180] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[180].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i)?; } record.function_queries[180].output_at(__i).to_array::() }, _ => aiur_fn_180(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); let __ret: [G; OUT_180] = [__v_5]; - record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[180].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16717,23 +16899,24 @@ const INPUT_SIZE_181: usize = 3; const IN_181: usize = 3; const OUT_181: usize = 8; fn aiur_fn_181( - inp: [G; IN_181], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + record.checkpoint(181); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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_178] = { let __args: [G; IN_178] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -16845,7 +17028,7 @@ fn aiur_fn_181( let __v_93: G = (__v_92 - __v_8); let __v_94: G = (__v_93 * __v_83); let __ret: [G; OUT_181] = [__v_43, __v_46, __v_71, __v_74, __v_76, __v_77, __v_91, __v_94]; - record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[181].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16854,61 +17037,62 @@ const INPUT_SIZE_182: usize = 24; const IN_182: usize = 24; const OUT_182: usize = 1; fn aiur_fn_182( - inp: [G; IN_182], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; + record.checkpoint(182); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_bool((__v_24 == G::ZERO)); let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; if (__v_27 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; if (__v_28 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; if (__v_29 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { @@ -16916,7 +17100,7 @@ fn aiur_fn_182( } let __v_32: G = G::from_u64(1); let __ret: [G; OUT_182] = [__v_32]; - record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[182].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -16927,18 +17111,19 @@ const INPUT_SIZE_183: usize = 6; const IN_183: usize = 6; const OUT_183: usize = 2; fn aiur_fn_183( - inp: [G; IN_183], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; + record.checkpoint(183); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; let __v_6: G = (__v_0 * __v_2); let __v_7: G = G::from_u64(7); let __v_8: G = (__v_1 * __v_3); @@ -16950,7 +17135,7 @@ fn aiur_fn_183( let __v_14: G = (__v_10 + __v_4); let __v_15: G = (__v_13 + __v_5); let __ret: [G; OUT_183] = [__v_14, __v_15]; - record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[183].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16959,16 +17144,17 @@ const INPUT_SIZE_184: usize = 4; const IN_184: usize = 4; const OUT_184: usize = 2; fn aiur_fn_184( - inp: [G; IN_184], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(184); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 * __v_4); @@ -16982,7 +17168,7 @@ fn aiur_fn_184( let __v_14: G = (__v_0 + __v_10); let __v_15: G = (__v_1 + __v_13); let __ret: [G; OUT_184] = [__v_14, __v_15]; - record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[184].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -16991,14 +17177,15 @@ const INPUT_SIZE_185: usize = 1; const IN_185: usize = 1; const OUT_185: usize = 1; fn aiur_fn_185( - inp: [G; IN_185], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(185); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -17007,13 +17194,13 @@ fn aiur_fn_185( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_185] = [__v_7]; - record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[185].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -17021,14 +17208,14 @@ fn aiur_fn_185( match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_2, __v_3, __v_6, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[184].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i)?; } record.function_queries[184].output_at(__i).to_array::() }, _ => aiur_fn_184(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[185].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i)?; } record.function_queries[185].output_at(__i).to_array::() }, _ => aiur_fn_185(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_185] = [__v_13]; - record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[185].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17047,28 +17234,29 @@ const INPUT_SIZE_186: usize = 15; const IN_186: usize = 15; const OUT_186: usize = 2; fn aiur_fn_186( - inp: [G; IN_186], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } }; + record.checkpoint(186); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[250].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i)?; } record.function_queries[250].output_at(__i).to_array::() }, _ => aiur_fn_250(__key, 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]; @@ -17077,7 +17265,7 @@ fn aiur_fn_186( 0u64 => { let __v_19: G = G::from_u64(0); let __ret: [G; OUT_186] = [__v_16, __v_19]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -17085,109 +17273,109 @@ fn aiur_fn_186( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_4, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_6, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_7, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_21, __v_22]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __ret: [G; OUT_186] = [__v_19, __v_20]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __ret: [G; OUT_186] = [__v_9, __v_10]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __ret: [G; OUT_186] = [__v_11, __v_12]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __ret: [G; OUT_186] = [__v_13, __v_14]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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_186] = [__v_23, __v_24]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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_186] = [__v_23, __v_24]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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); @@ -17199,11 +17387,11 @@ fn aiur_fn_186( let __v_29: G = (__v_20 * __v_21); let __v_30: G = (__v_28 + __v_29); let __ret: [G; OUT_186] = [__v_27, __v_30]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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); @@ -17211,7 +17399,7 @@ fn aiur_fn_186( let __v_23: G = G::from_u64(0); let __v_24: G = (__v_23 - __v_20); let __ret: [G; OUT_186] = [__v_22, __v_24]; - record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[186].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17225,53 +17413,54 @@ const INPUT_SIZE_187: usize = 19; const IN_187: usize = 19; const OUT_187: usize = 2; fn aiur_fn_187( - inp: [G; IN_187], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(187); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_187] = [__v_0, __v_1]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[187].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __ret: [G; OUT_187] = [__v_26, __v_27]; - record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[187].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17285,20 +17474,21 @@ const INPUT_SIZE_188: usize = 8; const IN_188: usize = 8; const OUT_188: usize = 4; fn aiur_fn_188( - inp: [G; IN_188], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(188); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = (__v_0 * __v_4); let __v_9: G = G::from_u64(7); let __v_10: G = (__v_1 * __v_5); @@ -17346,7 +17536,7 @@ fn aiur_fn_188( let __v_52: G = (__v_38 + __v_46); let __v_53: G = (__v_41 + __v_49); let __ret: [G; OUT_188] = [__v_50, __v_51, __v_52, __v_53]; - record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[188].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -17355,32 +17545,33 @@ const INPUT_SIZE_189: usize = 19; const IN_189: usize = 19; const OUT_189: usize = 4; fn aiur_fn_189( - inp: [G; IN_189], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(189); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; @@ -17391,27 +17582,27 @@ fn aiur_fn_189( let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); let __ret: [G; OUT_189] = [__v_22, __v_23, __v_24, __v_25]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[189].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i)?; } record.function_queries[189].output_at(__i).to_array::() }, _ => aiur_fn_189(__key, 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_188] = { let __args: [G; IN_188] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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_186] = { let __args: [G; IN_186] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, 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_189] = [__v_32, __v_33, __v_28, __v_29]; - record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[189].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17425,57 +17616,58 @@ const INPUT_SIZE_190: usize = 44; const IN_190: usize = 44; const OUT_190: usize = 2; fn aiur_fn_190( - inp: [G; IN_190], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; - let __v_38: G = inp[38]; - let __v_39: G = inp[39]; - let __v_40: G = inp[40]; - let __v_41: G = inp[41]; - let __v_42: G = inp[42]; - let __v_43: G = inp[43]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(190); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; + let __v_38: G = inp.values()[38]; + let __v_39: G = inp.values()[39]; + let __v_40: G = inp.values()[40]; + let __v_41: G = inp.values()[41]; + let __v_42: G = inp.values()[42]; + let __v_43: G = inp.values()[43]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -17483,13 +17675,13 @@ fn aiur_fn_190( match __v_44.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_190] = [__v_0, __v_1]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_45.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[189].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i)?; } record.function_queries[189].output_at(__i).to_array::() }, _ => aiur_fn_189(__key, 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]; @@ -17498,10 +17690,10 @@ fn aiur_fn_190( 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_186] = { let __args: [G; IN_186] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[186].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i)?; } record.function_queries[186].output_at(__i).to_array::() }, _ => aiur_fn_186(__key, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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]; @@ -17526,7 +17718,7 @@ fn aiur_fn_190( 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_188] = { let __args: [G; IN_188] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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]; @@ -17537,23 +17729,23 @@ fn aiur_fn_190( match __v_88.as_canonical_u64() { 0u64 => { let __v_89: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_89]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_89]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; let __v_91: G = __r_arr[1]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_7 + __v_92); let __v_94: G = (__v_7 + __v_93); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_36, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_36, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_98: G = __r_arr[0]; let __v_99: G = __r_arr[1]; let __v_100: G = (__v_98 + __v_18); let __v_101: G = (__v_99 + __v_19); let __v_102: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_36, __v_102]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_36, __v_102]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, 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); @@ -17562,23 +17754,23 @@ fn aiur_fn_190( 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_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_107, __v_108, __v_109, __v_110]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_115, __v_116]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_183] = { let __args: [G; IN_183] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_117, __v_118, __v_2, __v_3, __v_119, __v_120]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_121, __v_122]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17587,44 +17779,44 @@ fn aiur_fn_190( match __v_90.as_canonical_u64() { 0u64 => { let __v_91: G = (__v_7 + __v_7); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_91]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = G::from_u64(1); let __v_95: G = (__v_7 + __v_94); let __v_96: G = (__v_7 + __v_95); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_96]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_97: G = __r_arr[0]; let __v_98: G = __r_arr[1]; let __v_99: G = G::from_u64(2); let __v_100: G = (__v_7 + __v_99); let __v_101: G = (__v_7 + __v_100); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_101]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_101]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; let __v_103: G = __r_arr[1]; let __v_104: G = G::from_u64(3); let __v_105: G = (__v_7 + __v_104); let __v_106: G = (__v_7 + __v_105); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_106]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, 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_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_82, __v_83, __v_84, __v_85, __v_109, __v_110, __v_111, __v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[188].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i)?; } record.function_queries[188].output_at(__i).to_array::() }, _ => aiur_fn_188(__key, 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_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_1, __v_2, __v_3, __v_117, __v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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_183] = { let __args: [G; IN_183] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_119, __v_120, __v_2, __v_3, __v_121, __v_122]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, 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); @@ -17639,11 +17831,11 @@ fn aiur_fn_190( 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_190] = { let __args: [G; IN_190] = [__v_123, __v_124, __v_2, __v_3, __v_47, __v_126, __v_6, __v_128, __v_9, __v_9, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_137, __v_138]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17651,11 +17843,11 @@ fn aiur_fn_190( 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_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_92, __v_6, __v_7, __v_94, __v_9, __v_82, __v_83, __v_84, __v_85, __v_70, __v_71, __v_80, __v_81, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __ret: [G; OUT_190] = [__v_95, __v_96]; - record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[190].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -17675,43 +17867,44 @@ const INPUT_SIZE_191: usize = 28; const IN_191: usize = 28; const OUT_191: usize = 2; fn aiur_fn_191( - inp: [G; IN_191], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; + record.checkpoint(191); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_28, __v_29, __v_25, __v_26, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, 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); @@ -17760,7 +17953,7 @@ fn aiur_fn_191( let __v_75: G = (__v_21 * __v_69); let __v_76: G = (__v_22 * __v_66); let __v_77: G = (__v_75 + __v_76); - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_78: G = __loaded[0]; let __v_79: G = __loaded[1]; let __v_80: G = __loaded[2]; @@ -17768,42 +17961,42 @@ fn aiur_fn_191( match __v_78.as_canonical_u64() { 1u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_82]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_85]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, 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_183] = { let __args: [G; IN_183] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_30, __v_31, __v_25, __v_26, __v_90, __v_91]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = __r_arr[1]; let __v_94: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_94]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_94]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; let __v_96: G = __r_arr[1]; let __v_97: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_97]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_8, __v_97]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, 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_183] = { let __args: [G; IN_183] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_92, __v_93, __v_25, __v_26, __v_102, __v_103]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_104, __v_105]; - record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, 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); @@ -17814,11 +18007,11 @@ fn aiur_fn_191( 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_190] = { let __args: [G; IN_190] = [__v_30, __v_31, __v_25, __v_26, __v_2, __v_82, __v_83, __v_84, __v_3, __v_3, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_55, __v_58, __v_74, __v_77, __v_11, __v_32, __v_12, __v_33, __v_13, __v_34, __v_14, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, record, io_buffer, __cu)? } }; let __v_93: G = __r_arr[0]; let __v_94: G = __r_arr[1]; let __ret: [G; OUT_191] = [__v_93, __v_94]; - record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[191].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17832,20 +18025,21 @@ const INPUT_SIZE_192: usize = 8; const IN_192: usize = 8; const OUT_192: usize = 1; fn aiur_fn_192( - inp: [G; IN_192], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(192); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); @@ -17864,17 +18058,17 @@ fn aiur_fn_192( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); - let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 4] = [__v_24, __v_25, __v_25, __v_25]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_7, __v_23, __v_26]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_28: G = { let __values: [G; 4] = [__v_20, __v_6, __v_21, __v_27]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_29: G = { let __values: [G; 4] = [__v_18, __v_5, __v_19, __v_28]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_30: G = { let __values: [G; 4] = [__v_16, __v_4, __v_17, __v_29]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_31: G = { let __values: [G; 4] = [__v_14, __v_3, __v_15, __v_30]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_192] = [__v_34]; - record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[192].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -17883,18 +18077,19 @@ const INPUT_SIZE_193: usize = 5; const IN_193: usize = 5; const OUT_193: usize = 2; fn aiur_fn_193( - inp: [G; IN_193], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(193); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -17904,7 +18099,7 @@ fn aiur_fn_193( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __ret: [G; OUT_193] = [__v_9, __v_10]; - record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[193].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -17924,13 +18119,13 @@ fn aiur_fn_193( 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_193] = { let __args: [G; IN_193] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_8, __v_1, __v_2, __v_21, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[193].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i)?; } record.function_queries[193].output_at(__i).to_array::() }, _ => aiur_fn_193(__key, 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_193] = [__v_27, __v_28]; - record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[193].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -17944,126 +18139,127 @@ const INPUT_SIZE_194: usize = 1; const IN_194: usize = 1; const OUT_194: usize = 1; fn aiur_fn_194( - inp: [G; IN_194], + inp: QueryKey, 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]; + record.checkpoint(194); + let __v_0: G = inp.values()[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); let __ret: [G; OUT_194] = [__v_1]; - record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[194].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -18074,26 +18270,27 @@ const INPUT_SIZE_195: usize = 4; const IN_195: usize = 4; const OUT_195: usize = 2; fn aiur_fn_195( - inp: [G; IN_195], + inp: QueryKey, 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 __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(195); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_195] = [__v_6, __v_9]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { @@ -18101,25 +18298,25 @@ fn aiur_fn_195( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_5, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_195] = [__v_6, __v_9]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_195] = [__v_6, __v_8]; - record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[195].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -18138,33 +18335,34 @@ const INPUT_SIZE_196: usize = 20; const IN_196: usize = 20; const OUT_196: usize = 1; fn aiur_fn_196( - inp: [G; IN_196], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + record.checkpoint(196); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -18177,46 +18375,46 @@ fn aiur_fn_196( 1u64 => { let __v_28: G = G::from_u64(1); let __ret: [G; OUT_196] = [__v_28]; - record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[196].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_2, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[194].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i)?; } record.function_queries[194].output_at(__i).to_array::() }, _ => aiur_fn_194(__key, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_3, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = G::from_u64(1); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_32, __v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_37, __v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_1, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_42.as_canonical_u64() { 0u64 => { let __v_44: G = G::from_u64(1); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_46, __v_49]; }, 1u64 => { @@ -18224,20 +18422,20 @@ fn aiur_fn_196( 0u64 => { let __v_44: G = G::from_u64(1); let __v_45: G = G::from_u64(1); - let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_45, __v_45, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); - let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_48, __v_48, __v_48]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_46, __v_49]; }, 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = G::from_u64(1); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_44, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_44, __v_47]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; break '__mc_0 [__v_46, __v_48]; }, @@ -18253,14 +18451,14 @@ fn aiur_fn_196( }; let __v_44: G = __mc_out___mc_0[0]; let __v_45: G = __mc_out___mc_0[1]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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_178] = { let __args: [G; IN_178] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -18389,18 +18587,18 @@ fn aiur_fn_196( let __v_153: G = G::from_u64(0); let __v_154: G = G::from_u64(1); let __v_155: G = G::from_u64(1); - let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __v_156: G = { let __values: [G; 4] = [__v_154, __v_155, __v_155, __v_155]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_157: G = { let __values: [G; 4] = [__v_152, __v_31, __v_153, __v_156]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_158: G = { let __values: [G; 4] = [__v_150, __v_30, __v_151, __v_157]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_159: G = { let __values: [G; 4] = [__v_148, __v_11, __v_149, __v_158]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_160: G = { let __values: [G; 4] = [__v_146, __v_10, __v_147, __v_159]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_161: G = { let __values: [G; 4] = [__v_144, __v_15, __v_145, __v_160]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_162: G = { let __values: [G; 4] = [__v_142, __v_14, __v_143, __v_161]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_163: G = { let __values: [G; 4] = [__v_140, __v_13, __v_141, __v_162]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_164: G = { let __values: [G; 4] = [__v_138, __v_12, __v_139, __v_163]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[180].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i)?; } record.function_queries[180].output_at(__i).to_array::() }, _ => aiur_fn_180(__key, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[178].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i)?; } record.function_queries[178].output_at(__i).to_array::() }, _ => aiur_fn_178(__key, 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); @@ -18419,7 +18617,7 @@ fn aiur_fn_196( } let __v_176: G = G::from_u64(0); let __v_177: G = G::from_u64(0); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_176, __v_177, __v_16, __v_17, __v_23, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[187].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i)?; } record.function_queries[187].output_at(__i).to_array::() }, _ => aiur_fn_187(__key, 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); @@ -18468,7 +18666,7 @@ fn aiur_fn_196( let __v_223: G = (__v_114 * __v_217); let __v_224: G = (__v_117 * __v_214); let __v_225: G = (__v_223 + __v_224); - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_226: G = __loaded[0]; let __v_227: G = __loaded[1]; let __v_228: G = __loaded[2]; @@ -18476,40 +18674,40 @@ fn aiur_fn_196( let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_226.as_canonical_u64() { 1u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_230]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_230]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_231: G = __r_arr[0]; let __v_232: G = __r_arr[1]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_39, __v_233]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_39, __v_233]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, 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_183] = { let __args: [G; IN_183] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_178, __v_179, __v_16, __v_17, __v_238, __v_239]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_240: G = __r_arr[0]; let __v_241: G = __r_arr[1]; let __v_242: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_242]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_41, __v_242]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, record, io_buffer, __cu)? } }; let __v_243: G = __r_arr[0]; let __v_244: G = __r_arr[1]; let __v_245: G = G::from_u64(1); - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_39, __v_245]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_39, __v_245]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[252].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i)?; } record.function_queries[252].output_at(__i).to_array::() }, _ => aiur_fn_252(__key, 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_183] = { let __args: [G; IN_183] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_240, __v_241, __v_16, __v_17, __v_250, __v_251]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[183].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i)?; } record.function_queries[183].output_at(__i).to_array::() }, _ => aiur_fn_183(__key, record, io_buffer, __cu)? } }; let __v_252: G = __r_arr[0]; let __v_253: G = __r_arr[1]; break '__mc_1 [__v_252, __v_253]; }, 0u64 => { let __v_230: G = G::from_u64(0); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, 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); @@ -18520,7 +18718,7 @@ fn aiur_fn_196( 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_190] = { let __args: [G; IN_190] = [__v_178, __v_179, __v_16, __v_17, __v_25, __v_230, __v_231, __v_232, __v_26, __v_26, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_203, __v_206, __v_222, __v_225, __v_12, __v_180, __v_13, __v_181, __v_14, __v_182, __v_15, __v_183, __v_21, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_164, __v_86, __v_89, __v_114, __v_117, __v_119, __v_120]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[190].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i)?; } record.function_queries[190].output_at(__i).to_array::() }, _ => aiur_fn_190(__key, 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]; @@ -18532,19 +18730,19 @@ fn aiur_fn_196( }; let __v_230: G = __mc_out___mc_1[0]; let __v_231: G = __mc_out___mc_1[1]; - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8, __v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_232: G = __r_arr[0]; let __v_233: G = G::from_u64(0); - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_232, __v_233]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_232, __v_233]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[243].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i)?; } record.function_queries[243].output_at(__i).to_array::() }, _ => aiur_fn_243(__key, record, io_buffer, __cu)? } }; let __v_234: G = __r_arr[0]; - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_234]; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_234]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[185].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i)?; } record.function_queries[185].output_at(__i).to_array::() }, _ => aiur_fn_185(__key, record, io_buffer, __cu)? } }; let __v_235: G = __r_arr[0]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_18, __v_19, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[177].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i)?; } record.function_queries[177].output_at(__i).to_array::() }, _ => aiur_fn_177(__key, 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_193] = { let __args: [G; IN_193] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_235, __v_236, __v_237, __v_238, __v_239]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[193].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i)?; } record.function_queries[193].output_at(__i).to_array::() }, _ => aiur_fn_193(__key, 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); @@ -18556,12 +18754,12 @@ fn aiur_fn_196( let __v_248: G = (__v_231 * __v_134); let __v_249: G = (__v_247 + __v_248); let __v_250: G = G::from_u64(32); - let __v_251: G = if unconstrained { Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record) }; + let __v_251: G = if unconstrained { Bytes2::validate_inputs(&__v_28, &__v_250)?; Bytes2::less_than(&__v_28, &__v_250) } else { bytes2_less_than_value(__v_28, __v_250, record)? }; let __v_252: G = G::from_u64(1); if (__v_251 != __v_252) { return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_235]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_235]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, 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)); @@ -18580,10 +18778,10 @@ fn aiur_fn_196( } let __v_263: G = G::from_u64(1); let __v_264: G = (__v_9 + __v_263); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_264, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_265: G = __r_arr[0]; let __ret: [G; OUT_196] = [__v_265]; - record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[196].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -18599,16 +18797,17 @@ const INPUT_SIZE_197: usize = 3; const IN_197: usize = 3; const OUT_197: usize = 2; fn aiur_fn_197( - inp: [G; IN_197], + inp: QueryKey, 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 = inp[2]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(197); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -18624,7 +18823,7 @@ fn aiur_fn_197( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __ret: [G; OUT_197] = [__v_13, __v_14]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[197].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -18650,7 +18849,7 @@ fn aiur_fn_197( 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_197] = { let __args: [G; IN_197] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0, __v_1, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[197].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i)?; } record.function_queries[197].output_at(__i).to_array::() }, _ => aiur_fn_197(__key, 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); @@ -18664,7 +18863,7 @@ fn aiur_fn_197( let __v_45: G = (__v_33 + __v_41); let __v_46: G = (__v_34 + __v_44); let __ret: [G; OUT_197] = [__v_45, __v_46]; - record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[197].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -18678,31 +18877,32 @@ const INPUT_SIZE_198: usize = 7; const IN_198: usize = 7; const OUT_198: usize = 2; fn aiur_fn_198( - inp: [G; IN_198], + inp: QueryKey, 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 = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(198); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_198] = [__v_0, __v_1]; - record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[198].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_5, __v_6, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[197].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i)?; } record.function_queries[197].output_at(__i).to_array::() }, _ => aiur_fn_197(__key, 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); @@ -18732,11 +18932,11 @@ fn aiur_fn_198( 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_198] = { let __args: [G; IN_198] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_31, __v_32, __v_9, __v_3, __v_4, __v_5, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; let __ret: [G; OUT_198] = [__v_33, __v_34]; - record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[198].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -18750,59 +18950,60 @@ const INPUT_SIZE_199: usize = 38; const IN_199: usize = 38; const OUT_199: usize = 1; fn aiur_fn_199( - inp: [G; IN_199], + inp: QueryKey, 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 = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __v_21: G = inp[21]; - let __v_22: G = inp[22]; - let __v_23: G = inp[23]; - let __v_24: G = inp[24]; - let __v_25: G = inp[25]; - let __v_26: G = inp[26]; - let __v_27: G = inp[27]; - let __v_28: G = inp[28]; - let __v_29: G = inp[29]; - let __v_30: G = inp[30]; - let __v_31: G = inp[31]; - let __v_32: G = inp[32]; - let __v_33: G = inp[33]; - let __v_34: G = inp[34]; - let __v_35: G = inp[35]; - let __v_36: G = inp[36]; - let __v_37: G = inp[37]; + record.checkpoint(199); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __v_21: G = inp.values()[21]; + let __v_22: G = inp.values()[22]; + let __v_23: G = inp.values()[23]; + let __v_24: G = inp.values()[24]; + let __v_25: G = inp.values()[25]; + let __v_26: G = inp.values()[26]; + let __v_27: G = inp.values()[27]; + let __v_28: G = inp.values()[28]; + let __v_29: G = inp.values()[29]; + let __v_30: G = inp.values()[30]; + let __v_31: G = inp.values()[31]; + let __v_32: G = inp.values()[32]; + let __v_33: G = inp.values()[33]; + let __v_34: G = inp.values()[34]; + let __v_35: G = inp.values()[35]; + let __v_36: G = inp.values()[36]; + let __v_37: G = inp.values()[37]; match __v_0.as_canonical_u64() { _ => { match __v_0.as_canonical_u64() { _ => { match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { @@ -18810,7 +19011,7 @@ fn aiur_fn_199( 0u64 => { let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); - let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_42]; }, 1u64 => { @@ -18822,15 +19023,15 @@ fn aiur_fn_199( } }; let __v_40: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_17, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_17, __v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_13, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_13, __v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_40, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_12, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_12, __v_43]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(109); @@ -18860,24 +19061,24 @@ fn aiur_fn_199( let __v_71: G = G::from_u64(118); let __v_72: G = G::from_u64(0); let __v_73: G = G::from_u64(48); - let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __v_82]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_70, __v_71, __v_74]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_76: G = { let __values: [G; 3] = [__v_68, __v_69, __v_75]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_66, __v_67, __v_76]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_78: G = { let __values: [G; 3] = [__v_64, __v_65, __v_77]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_62, __v_63, __v_78]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_80: G = { let __values: [G; 3] = [__v_60, __v_61, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_58, __v_59, __v_80]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_82: G = { let __values: [G; 3] = [__v_56, __v_57, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_54, __v_55, __v_82]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_84: G = { let __values: [G; 3] = [__v_52, __v_53, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_50, __v_51, __v_84]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_86: G = { let __values: [G; 3] = [__v_48, __v_49, __v_85]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_46, __v_47, __v_86]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_88: G = G::from_u64(1); let __v_89: G = G::from_u64(1); - let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_87, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_90: G = { let __values: [G; 3] = [__v_88, __v_89, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_87, __v_90]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __v_93: G = __r_arr[2]; @@ -18898,17 +19099,17 @@ fn aiur_fn_199( let __v_108: G = __r_arr[17]; let __v_109: G = G::from_u64(1); let __v_110: G = G::from_u64(1); - let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_111: G = { let __values: [G; 3] = [__v_109, __v_110, __v_110]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_111]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_112: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_107, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_107, __v_113]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(1); let __v_116: G = G::from_u64(1); - let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_114, __v_117]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_117: G = { let __values: [G; 3] = [__v_115, __v_116, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_114, __v_117]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_118: G = __r_arr[0]; let __v_119: G = __r_arr[1]; let __v_120: G = __r_arr[2]; @@ -18929,26 +19130,26 @@ fn aiur_fn_199( let __v_135: G = __r_arr[17]; let __v_136: G = G::from_u64(1); let __v_137: G = G::from_u64(1); - let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_138: G = { let __values: [G; 3] = [__v_136, __v_137, __v_137]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_138]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_139]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_140: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_134, __v_140]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_134, __v_140]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_141, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_141, __v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_142: G = __r_arr[0]; let __v_143: G = G::from_u64(1); let __v_144: G = G::from_u64(1); - let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16, __v_145]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_145: G = { let __values: [G; 3] = [__v_143, __v_144, __v_144]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_16, __v_145]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_146: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_142, __v_146]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_142, __v_146]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_147: G = __r_arr[0]; let __v_148: G = G::from_u64(1); let __v_149: G = G::from_u64(1); - let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_147, __v_150]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_150: G = { let __values: [G; 3] = [__v_148, __v_149, __v_149]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_147, __v_150]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; @@ -18967,12 +19168,12 @@ fn aiur_fn_199( let __v_166: G = __r_arr[15]; let __v_167: G = __r_arr[16]; let __v_168: G = __r_arr[17]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_167, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_167, __v_15]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_169: G = __r_arr[0]; let __v_170: G = G::from_u64(1); let __v_171: G = G::from_u64(1); - let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_169, __v_172]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_172: G = { let __values: [G; 3] = [__v_170, __v_171, __v_171]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_169, __v_172]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -19161,27 +19362,27 @@ fn aiur_fn_199( let __v_358: G = (__v_181 + __v_357); let __v_359: G = G::from_u64(0); let __v_360: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_359, __v_360, __v_36, __v_211, __v_232, __v_253, __v_274]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_361: G = __r_arr[0]; let __v_362: G = __r_arr[1]; let __v_363: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_38, __v_39, __v_17, __v_16, __v_34, __v_35, __v_32, __v_33, __v_31, __v_363, __v_361, __v_362, __v_211, __v_232, __v_253, __v_274, __v_295, __v_316, __v_337, __v_358]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); let __v_368: G = G::from_u64(1); - let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_369: G = { let __values: [G; 3] = [__v_367, __v_368, __v_368]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_32.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_369]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_33, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_33, __v_369]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_370: G = __r_arr[0]; break '__mc_1 [__v_370]; }, @@ -19191,18 +19392,18 @@ fn aiur_fn_199( } }; let __v_370: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_31, __v_370]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_31, __v_370]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_371: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_35, __v_371]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_35, __v_371]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_372: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_34, __v_372]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_34, __v_372]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_373: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_189, __v_373]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_189, __v_373]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_374: G = __r_arr[0]; let __v_375: G = G::from_u64(1); let __v_376: G = G::from_u64(1); - let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_374, __v_377]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_377: G = { let __values: [G; 3] = [__v_375, __v_376, __v_376]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_374, __v_377]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_378: G = __r_arr[0]; let __v_379: G = __r_arr[1]; let __v_380: G = __r_arr[2]; @@ -19263,28 +19464,28 @@ fn aiur_fn_199( let __v_435: G = (__v_420 + __v_434); let __v_436: G = (__v_418 + __v_435); let __v_437: G = (__v_386 + __v_436); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_394, __v_18, __v_19, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_394, __v_18, __v_19, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_438: G = __r_arr[0]; let __v_439: G = __r_arr[1]; let __v_440: G = G::from_u64(1); let __v_441: G = G::from_u64(1); - let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_22, __v_442]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_442: G = { let __values: [G; 3] = [__v_440, __v_441, __v_441]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_22, __v_442]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_443: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_439, __v_443]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_439, __v_443]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_444: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_444, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_444, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_445: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_445, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_446: G = __r_arr[0]; let __v_447: G = __r_arr[1]; let __v_448: G = (__v_366 + __v_0); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_446, __v_447, __v_4, __v_448]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_446, __v_447, __v_4, __v_448]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_449: G = __r_arr[0]; let __v_450: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_20, __v_21, __v_450, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_20, __v_21, __v_450, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_451: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_446, __v_447, __v_451, __v_416, __v_437, __v_34, __v_35, __v_31, __v_32, __v_33, __v_13, __v_14, __v_15, __v_40, __v_39, __v_17, __v_337, __v_358, __v_365, __v_0, __v_448, __v_438, __v_18, __v_22, __v_366]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_452: G = __r_arr[0]; let __v_453: G = G::from_u64(0); if (__v_1 != __v_453) { @@ -19298,15 +19499,15 @@ fn aiur_fn_199( if (__v_3 != __v_455) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_455.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; let __v_457: G = G::from_u64(1); if (__v_456 != __v_457) { return Err(ExecError::AssertEqMismatch { lhs: __v_456.as_canonical_u64(), rhs: __v_457.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_458: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_459: G = __r_arr[0]; let __v_460: G = (__v_458 - __v_459); let __v_461: G = G::from_bool((__v_460 == G::ZERO)); @@ -19314,9 +19515,9 @@ fn aiur_fn_199( if (__v_461 != __v_462) { return Err(ExecError::AssertEqMismatch { lhs: __v_461.as_canonical_u64(), rhs: __v_462.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_463: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_464: G = __r_arr[0]; let __v_465: G = (__v_463 - __v_464); let __v_466: G = G::from_bool((__v_465 == G::ZERO)); @@ -19324,7 +19525,7 @@ fn aiur_fn_199( if (__v_466 != __v_467) { return Err(ExecError::AssertEqMismatch { lhs: __v_466.as_canonical_u64(), rhs: __v_467.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_468: G = __r_arr[0]; let __v_469: G = (__v_468 - __v_366); let __v_470: G = G::from_bool((__v_469 == G::ZERO)); @@ -19332,16 +19533,16 @@ fn aiur_fn_199( if (__v_470 != __v_471) { return Err(ExecError::AssertEqMismatch { lhs: __v_470.as_canonical_u64(), rhs: __v_471.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_472: G = __r_arr[0]; let __v_473: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_32, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_474: G = __r_arr[0]; let __v_475: G = (__v_473 + __v_474); if (__v_472 != __v_475) { return Err(ExecError::AssertEqMismatch { lhs: __v_472.as_canonical_u64(), rhs: __v_475.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_476: G = __r_arr[0]; let __v_477: G = (__v_476 - __v_366); let __v_478: G = G::from_bool((__v_477 == G::ZERO)); @@ -19349,29 +19550,29 @@ fn aiur_fn_199( if (__v_478 != __v_479) { return Err(ExecError::AssertEqMismatch { lhs: __v_478.as_canonical_u64(), rhs: __v_479.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_480: G = __r_arr[0]; let __v_481: G = G::from_u64(1); if (__v_480 != __v_481) { return Err(ExecError::AssertEqMismatch { lhs: __v_480.as_canonical_u64(), rhs: __v_481.as_canonical_u64(), msg: None }); } let __v_482: G = G::from_u64(33); - let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_483: G = { let __a_val = __v_448.as_canonical_u64(); let __b_val = __v_482.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_484: G = G::from_u64(1); if (__v_483 != __v_484) { return Err(ExecError::AssertEqMismatch { lhs: __v_483.as_canonical_u64(), rhs: __v_484.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_20, __v_449, __v_13, __v_14, __v_15, __v_40, __v_32, __v_33, __v_39, __v_17, __v_365, __v_0, __v_448]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_485: G = __r_arr[0]; let __v_486: G = G::from_u64(1); if (__v_485 != __v_486) { return Err(ExecError::AssertEqMismatch { lhs: __v_485.as_canonical_u64(), rhs: __v_486.as_canonical_u64(), msg: None }); } let __v_487: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_21, __v_18, __v_452, __v_449, __v_487, __v_448]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_488: G = __r_arr[0]; let __ret: [G; OUT_199] = [__v_488]; - record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[199].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19390,14 +19591,15 @@ const INPUT_SIZE_200: usize = 1; const IN_200: usize = 1; const OUT_200: usize = 1; fn aiur_fn_200( - inp: [G; IN_200], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(200); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -19405,7 +19607,7 @@ fn aiur_fn_200( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_200] = [__v_4]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[200].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { @@ -19416,10 +19618,10 @@ fn aiur_fn_200( 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_200] = { let __args: [G; IN_200] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_200] = [__v_8]; - record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[200].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -19433,15 +19635,16 @@ const INPUT_SIZE_201: usize = 2; const IN_201: usize = 2; const OUT_201: usize = 1; fn aiur_fn_201( - inp: [G; IN_201], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + record.checkpoint(201); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -19454,13 +19657,13 @@ fn aiur_fn_201( 1u64 => { let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); - let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_201] = [__v_12]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; @@ -19468,19 +19671,19 @@ fn aiur_fn_201( 0u64 => { match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __ret: [G; OUT_201] = [__v_13]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_201] = [__v_15]; - record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[201].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19501,15 +19704,16 @@ const INPUT_SIZE_202: usize = 2; const IN_202: usize = 2; const OUT_202: usize = 1; fn aiur_fn_202( - inp: [G; IN_202], + inp: QueryKey, 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 __v_1: G = inp[1]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(202); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -19518,13 +19722,13 @@ fn aiur_fn_202( 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 4] = [__v_6, __v_7, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_202] = [__v_8]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_6: G = __loaded[0]; let __v_7: G = __loaded[1]; let __v_8: G = __loaded[2]; @@ -19532,19 +19736,19 @@ fn aiur_fn_202( 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __ret: [G; OUT_202] = [__v_9]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_202] = [__v_11]; - record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[202].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19565,21 +19769,22 @@ const INPUT_SIZE_203: usize = 1; const IN_203: usize = 1; const OUT_203: usize = 2; fn aiur_fn_203( - inp: [G; IN_203], + inp: QueryKey, 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + record.checkpoint(203); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_203] = [__v_3, __v_4]; - record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[203].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -19588,39 +19793,40 @@ const INPUT_SIZE_204: usize = 2; const IN_204: usize = 2; const OUT_204: usize = 2; fn aiur_fn_204( - inp: [G; IN_204], + inp: QueryKey, 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 __v_1: G = inp[1]; + record.checkpoint(204); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_204] = [__v_4, __v_0]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_3, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, 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_204] = { let __args: [G; IN_204] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); - let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_204] = [__v_11, __v_9]; - record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[204].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19631,21 +19837,22 @@ const INPUT_SIZE_205: usize = 1; const IN_205: usize = 1; const OUT_205: usize = 2; fn aiur_fn_205( - inp: [G; IN_205], + inp: QueryKey, 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 __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + record.checkpoint(205); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __ret: [G; OUT_205] = [__v_3, __v_4]; - record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[205].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -19654,25 +19861,26 @@ const INPUT_SIZE_206: usize = 2; const IN_206: usize = 2; const OUT_206: usize = 2; fn aiur_fn_206( - inp: [G; IN_206], + inp: QueryKey, 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 __v_1: G = inp[1]; + record.checkpoint(206); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_206] = [__v_4, __v_0]; - record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[26].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i); } let __ret: [G; OUT_26] = unsafe { *(record.function_queries[26].output_at(__i).as_ptr() as *const [G; OUT_26]) }; __ret }, _ => aiur_fn_26(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[26].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[26].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[26].bump_multiplicity(__i)?; } record.function_queries[26].output_at(__i).to_array::() }, _ => aiur_fn_26(__key, 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]; @@ -19684,13 +19892,13 @@ fn aiur_fn_206( 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_206] = { let __args: [G; IN_206] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_10, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[206].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i)?; } record.function_queries[206].output_at(__i).to_array::() }, _ => aiur_fn_206(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); - let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = { 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_206] = [__v_16, __v_14]; - record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[206].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -19701,208 +19909,209 @@ const INPUT_SIZE_207: usize = 1; const IN_207: usize = 1; const OUT_207: usize = 2; fn aiur_fn_207( - inp: [G; IN_207], + inp: QueryKey, 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; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(207); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_7: G = __loaded[0]; let __v_8: G = __loaded[1]; let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_13: G = __loaded[0]; let __v_14: G = __loaded[1]; let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_16: G = __loaded[0]; let __v_17: G = __loaded[1]; let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_19: G = __loaded[0]; let __v_20: G = __loaded[1]; let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_22: G = __loaded[0]; let __v_23: G = __loaded[1]; let __v_24: G = __loaded[2]; match __v_22.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_25: G = __loaded[0]; let __v_26: G = __loaded[1]; let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_28: G = __loaded[0]; let __v_29: G = __loaded[1]; let __v_30: G = __loaded[2]; match __v_28.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_31: G = __loaded[0]; let __v_32: G = __loaded[1]; let __v_33: G = __loaded[2]; match __v_31.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; match __v_34.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_37: G = __loaded[0]; let __v_38: G = __loaded[1]; let __v_39: G = __loaded[2]; match __v_37.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_40: G = __loaded[0]; let __v_41: G = __loaded[1]; let __v_42: G = __loaded[2]; match __v_40.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_43: G = __loaded[0]; let __v_44: G = __loaded[1]; let __v_45: G = __loaded[2]; match __v_43.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_46: G = __loaded[0]; let __v_47: G = __loaded[1]; let __v_48: G = __loaded[2]; match __v_46.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_49: G = __loaded[0]; let __v_50: G = __loaded[1]; let __v_51: G = __loaded[2]; match __v_49.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; match __v_52.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_55: G = __loaded[0]; let __v_56: G = __loaded[1]; let __v_57: G = __loaded[2]; match __v_55.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_58: G = __loaded[0]; let __v_59: G = __loaded[1]; let __v_60: G = __loaded[2]; match __v_58.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_61: G = __loaded[0]; let __v_62: G = __loaded[1]; let __v_63: G = __loaded[2]; match __v_61.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_64: G = __loaded[0]; let __v_65: G = __loaded[1]; let __v_66: G = __loaded[2]; match __v_64.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_67: G = __loaded[0]; let __v_68: G = __loaded[1]; let __v_69: G = __loaded[2]; match __v_67.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_70: G = __loaded[0]; let __v_71: G = __loaded[1]; let __v_72: G = __loaded[2]; match __v_70.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_73: G = __loaded[0]; let __v_74: G = __loaded[1]; let __v_75: G = __loaded[2]; match __v_73.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_76: G = __loaded[0]; let __v_77: G = __loaded[1]; let __v_78: G = __loaded[2]; match __v_76.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_79: G = __loaded[0]; let __v_80: G = __loaded[1]; let __v_81: G = __loaded[2]; match __v_79.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_82: G = __loaded[0]; let __v_83: G = __loaded[1]; let __v_84: G = __loaded[2]; match __v_82.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_85: G = __loaded[0]; let __v_86: G = __loaded[1]; let __v_87: G = __loaded[2]; match __v_85.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_88: G = __loaded[0]; let __v_89: G = __loaded[1]; let __v_90: G = __loaded[2]; match __v_88.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_91: G = __loaded[0]; let __v_92: G = __loaded[1]; let __v_93: G = __loaded[2]; match __v_91.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_94: G = __loaded[0]; let __v_95: G = __loaded[1]; let __v_96: G = __loaded[2]; match __v_94.as_canonical_u64() { 0u64 => { - let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_207] = [__v_97, __v_96]; - record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[207].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20071,15 +20280,16 @@ const INPUT_SIZE_208: usize = 2; const IN_208: usize = 2; const OUT_208: usize = 1; fn aiur_fn_208( - inp: [G; IN_208], + inp: QueryKey, 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]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(208); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -20113,71 +20323,71 @@ fn aiur_fn_208( let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; let __v_34: G = G::from_u64(0); - let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_96: G = G::from_u64(0); - let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_208] = [__v_97]; - record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[208].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20186,14 +20396,15 @@ const INPUT_SIZE_209: usize = 1; const IN_209: usize = 1; const OUT_209: usize = 8; fn aiur_fn_209( - inp: [G; IN_209], + inp: QueryKey, 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 __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(209); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -20299,7 +20510,7 @@ fn aiur_fn_209( let __v_103: G = (__v_97 + __v_102); let __v_104: G = (__v_29 + __v_103); let __ret: [G; OUT_209] = [__v_41, __v_50, __v_59, __v_68, __v_77, __v_86, __v_95, __v_104]; - record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[209].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20308,28 +20519,29 @@ const INPUT_SIZE_210: usize = 2; const IN_210: usize = 2; const OUT_210: usize = 1; fn aiur_fn_210( - inp: [G; IN_210], + inp: QueryKey, 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]; + record.checkpoint(210); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_1, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); - let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_9]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __ret: [G; OUT_210] = [__v_10]; - record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[210].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20338,25 +20550,26 @@ const INPUT_SIZE_211: usize = 1; const IN_211: usize = 1; const OUT_211: usize = 1; fn aiur_fn_211( - inp: [G; IN_211], + inp: QueryKey, 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]; + record.checkpoint(211); + let __v_0: G = inp.values()[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); - let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[208].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i)?; } record.function_queries[208].output_at(__i).to_array::() }, _ => aiur_fn_208(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[65].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i)?; } record.function_queries[65].output_at(__i).to_array::() }, _ => aiur_fn_65(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_211] = [__v_8]; - record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[211].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20365,16 +20578,17 @@ const INPUT_SIZE_212: usize = 4; const IN_212: usize = 4; const OUT_212: usize = 1; fn aiur_fn_212( - inp: [G; IN_212], + inp: QueryKey, 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 __v_2: G = inp[2]; - let __v_3: G = inp[3]; + record.checkpoint(212); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[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); @@ -20385,7 +20599,7 @@ fn aiur_fn_212( let __v_11: G = (__v_9 * __v_10); let __v_12: G = (__v_11 + __v_3); let __ret: [G; OUT_212] = [__v_12]; - record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[212].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -20394,15 +20608,16 @@ const INPUT_SIZE_213: usize = 2; const IN_213: usize = 2; const OUT_213: usize = 1; fn aiur_fn_213( - inp: [G; IN_213], + inp: QueryKey, 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 __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(213); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -20435,7 +20650,7 @@ fn aiur_fn_213( let __v_31: G = __loaded[29]; let __v_32: G = __loaded[30]; let __v_33: G = __loaded[31]; - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_34: G = __loaded[0]; let __v_35: G = __loaded[1]; let __v_36: G = __loaded[2]; @@ -20638,22 +20853,22 @@ fn aiur_fn_213( 0u64 => { let __v_218: G = G::from_u64(1); let __ret: [G; OUT_213] = [__v_218]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !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 }; + 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_213] = [__v_219]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_219: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_219]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20661,18 +20876,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_200]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_200: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_200]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20680,18 +20895,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_181]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_181: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_181]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20699,18 +20914,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_162]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_162: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_162]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20718,18 +20933,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_143]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_143: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_143]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20737,18 +20952,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_124]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_124: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_124]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20756,18 +20971,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_105]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_105: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_105]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20775,18 +20990,18 @@ fn aiur_fn_213( } }, _ => { - 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 }; + 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_213] = [__v_86]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_86: G = G::from_u64(2); let __ret: [G; OUT_213] = [__v_86]; - record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[213].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -20799,44 +21014,45 @@ const INPUT_SIZE_214: usize = 1; const IN_214: usize = 1; const OUT_214: usize = 0; fn aiur_fn_214( - inp: [G; IN_214], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(214); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_214] = []; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_214] = []; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, 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_214] = { let __args: [G; IN_214] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[214].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i)?; } record.function_queries[214].output_at(__i).to_array::() }, _ => aiur_fn_214(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_214] = []; - record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[214].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20855,49 +21071,50 @@ const INPUT_SIZE_215: usize = 1; const IN_215: usize = 1; const OUT_215: usize = 2; fn aiur_fn_215( - inp: [G; IN_215], + inp: QueryKey, 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; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(215); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_215] = [__v_9, __v_4]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_215] = [__v_5, __v_2]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_3, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_215] = [__v_7, __v_6]; - record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[215].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20911,14 +21128,15 @@ const INPUT_SIZE_216: usize = 1; const IN_216: usize = 1; const OUT_216: usize = 1; fn aiur_fn_216( - inp: [G; IN_216], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(216); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -20926,20 +21144,20 @@ fn aiur_fn_216( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_216] = [__v_6]; - record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[216].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[216].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i)?; } record.function_queries[216].output_at(__i).to_array::() }, _ => aiur_fn_216(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_216] = [__v_7]; - record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[216].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -20953,14 +21171,15 @@ const INPUT_SIZE_217: usize = 1; const IN_217: usize = 1; const OUT_217: usize = 1; fn aiur_fn_217( - inp: [G; IN_217], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(217); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -20968,13 +21187,13 @@ fn aiur_fn_217( 1u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); - let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_217] = [__v_6]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -21012,27 +21231,27 @@ fn aiur_fn_217( let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); - let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); - let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_45: G = { let __values: [G; 3] = [__v_40, __v_41, __v_44]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_217] = [__v_45]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[217].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i)?; } record.function_queries[217].output_at(__i).to_array::() }, _ => aiur_fn_217(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_217] = [__v_10]; - record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[217].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21051,36 +21270,37 @@ const INPUT_SIZE_218: usize = 1; const IN_218: usize = 1; const OUT_218: usize = 1; fn aiur_fn_218( - inp: [G; IN_218], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(218); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_218] = [__v_2]; - record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[218].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[217].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i)?; } record.function_queries[217].output_at(__i).to_array::() }, _ => aiur_fn_217(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[218].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i)?; } record.function_queries[218].output_at(__i).to_array::() }, _ => aiur_fn_218(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __ret: [G; OUT_218] = [__v_8]; - record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[218].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21096,19 +21316,20 @@ const INPUT_SIZE_219: usize = 1; const IN_219: usize = 1; const OUT_219: usize = 1; fn aiur_fn_219( - inp: [G; IN_219], + inp: QueryKey, 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 __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } }; + record.checkpoint(219); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[216].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i)?; } record.function_queries[216].output_at(__i).to_array::() }, _ => aiur_fn_216(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[218].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i)?; } record.function_queries[218].output_at(__i).to_array::() }, _ => aiur_fn_218(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_219] = [__v_2]; - record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[219].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -21117,14 +21338,15 @@ const INPUT_SIZE_220: usize = 1; const IN_220: usize = 1; const OUT_220: usize = 1; fn aiur_fn_220( - inp: [G; IN_220], + inp: QueryKey, 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; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + record.checkpoint(220); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -21162,22 +21384,22 @@ fn aiur_fn_220( let __v_34: G = __io_pair.0; let __v_35: G = __io_pair.1; let __v_36: G = G::from_u64(5); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[215].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i)?; } record.function_queries[215].output_at(__i).to_array::() }, _ => aiur_fn_215(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[214].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i)?; } record.function_queries[214].output_at(__i).to_array::() }, _ => aiur_fn_214(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[219].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i)?; } record.function_queries[219].output_at(__i).to_array::() }, _ => aiur_fn_219(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = G::from_u64(226); if (__v_38 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("join: tree has the wrong Ixon tag".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -21192,20 +21414,20 @@ fn aiur_fn_220( 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_251] = { let __args: [G; IN_251] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[251].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i)?; } record.function_queries[251].output_at(__i).to_array::() }, _ => aiur_fn_251(__key, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); if (__v_49 != __v_50) { return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_50.as_canonical_u64(), msg: Some("join: a present tree must contain at least one leaf".to_string()) }); } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_42, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_42, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_220] = [__v_40]; - record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[220].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -21214,28 +21436,29 @@ const INPUT_SIZE_221: usize = 2; const IN_221: usize = 2; const OUT_221: usize = 1; fn aiur_fn_221( - inp: [G; IN_221], + inp: QueryKey, 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]; + record.checkpoint(221); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_0.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_221] = [__v_4]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __ret: [G; OUT_221] = [__v_2]; - record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[221].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21249,19 +21472,20 @@ const INPUT_SIZE_222: usize = 2; const IN_222: usize = 2; const OUT_222: usize = 0; fn aiur_fn_222( - inp: [G; IN_222], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(222); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -21270,7 +21494,7 @@ fn aiur_fn_222( match __v_5.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_222] = []; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21281,15 +21505,15 @@ fn aiur_fn_222( 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_222] = { let __args: [G; IN_222] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_222] = []; - record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[222].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21308,82 +21532,83 @@ const INPUT_SIZE_223: usize = 3; const IN_223: usize = 3; const OUT_223: usize = 0; fn aiur_fn_223( - inp: [G; IN_223], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(223); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_222] = { let __args: [G; IN_222] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[222].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i)?; } record.function_queries[222].output_at(__i).to_array::() }, _ => aiur_fn_222(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; 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_213] = { let __args: [G; IN_213] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_4, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_223] = { let __args: [G; IN_223] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_1, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_223] = { let __args: [G; IN_223] = [__v_5, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_223] = { let __args: [G; IN_223] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_0, __v_8, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_223] = []; - record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[223].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21409,19 +21634,20 @@ const INPUT_SIZE_224: usize = 2; const IN_224: usize = 2; const OUT_224: usize = 4; fn aiur_fn_224( - inp: [G; IN_224], + inp: QueryKey, 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(224); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -21432,13 +21658,13 @@ fn aiur_fn_224( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __ret: [G; OUT_224] = [__v_8, __v_9, __v_9, __v_9]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_8, __v_6, __v_0, __v_7]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21451,29 +21677,29 @@ fn aiur_fn_224( 1u64 => { let __v_8: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_8, __v_3, __v_4, __v_1]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, 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_224] = [__v_9, __v_3, __v_4, __v_1]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_9, __v_3, __v_4, __v_7]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __ret: [G; OUT_224] = [__v_9, __v_6, __v_0, __v_7]; - record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[224].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21494,15 +21720,16 @@ const INPUT_SIZE_225: usize = 2; const IN_225: usize = 2; const OUT_225: usize = 2; fn aiur_fn_225( - inp: [G; IN_225], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(225); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -21510,31 +21737,31 @@ fn aiur_fn_225( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_5, __v_1]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_3, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[213].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i)?; } record.function_queries[213].output_at(__i).to_array::() }, _ => aiur_fn_213(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[225].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i)?; } record.function_queries[225].output_at(__i).to_array::() }, _ => aiur_fn_225(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __ret: [G; OUT_225] = [__v_6, __v_7]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); let __ret: [G; OUT_225] = [__v_6, __v_4]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_225] = [__v_6, __v_1]; - record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[225].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21550,24 +21777,25 @@ const INPUT_SIZE_226: usize = 4; const IN_226: usize = 4; const OUT_226: usize = 0; fn aiur_fn_226( - inp: [G; IN_226], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; + record.checkpoint(226); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[224].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i)?; } record.function_queries[224].output_at(__i).to_array::() }, _ => aiur_fn_224(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -21583,36 +21811,36 @@ fn aiur_fn_226( 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_226] = []; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[225].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i)?; } record.function_queries[225].output_at(__i).to_array::() }, _ => aiur_fn_225(__key, 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_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_226] = []; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_10: G = __loaded[0]; let __v_11: G = __loaded[1]; let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7, __v_9, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_226] = []; - record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[226].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21633,36 +21861,37 @@ const INPUT_SIZE_227: usize = 3; const IN_227: usize = 3; const OUT_227: usize = 2; fn aiur_fn_227( - inp: [G; IN_227], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; + record.checkpoint(227); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_227] = [__v_0, __v_2]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[227].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, 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_210] = { let __args: [G; IN_210] = [__v_5, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_5, __v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; break '__mc_0 [__v_7]; }, @@ -21670,18 +21899,18 @@ fn aiur_fn_227( }; 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_9: G = if unconstrained { Bytes2::validate_inputs(&__v_3, &__v_8)?; 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_227] = { let __args: [G; IN_227] = [__v_7, __v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_12, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[227].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i)?; } record.function_queries[227].output_at(__i).to_array::() }, _ => aiur_fn_227(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __ret: [G; OUT_227] = [__v_13, __v_14]; - record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[227].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21692,16 +21921,17 @@ const INPUT_SIZE_228: usize = 2; const IN_228: usize = 2; const OUT_228: usize = 1; fn aiur_fn_228( - inp: [G; IN_228], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(228); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(6); - let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<32>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -21738,20 +21968,20 @@ fn aiur_fn_228( let __v_35: G = __io_pair.0; let __v_36: G = __io_pair.1; let __v_37: G = G::from_u64(6); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_37, __v_35, __v_36]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_37, __v_35, __v_36]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, 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_42: G = if unconstrained { Bytes2::validate_inputs(&__v_39, &__v_41)?; Bytes2::less_than(&__v_39, &__v_41) } else { bytes2_less_than_value(__v_39, __v_41, record)? }; let __v_43: G = G::from_u64(1); if (__v_42 != __v_43) { return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("structural join: discharge choice must be 0 or 1".to_string()) }); } match __v_39.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_40.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_44: G = __loaded[0]; let __v_45: G = __loaded[1]; let __v_46: G = __loaded[2]; @@ -21768,25 +21998,25 @@ fn aiur_fn_228( } let __v_49: G = G::from_u64(0); let __ret: [G; OUT_228] = [__v_49]; - record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[228].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[211].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i)?; } record.function_queries[211].output_at(__i).to_array::() }, _ => aiur_fn_211(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_46, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_46, __v_44, __v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[227].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i)?; } record.function_queries[227].output_at(__i).to_array::() }, _ => aiur_fn_227(__key, 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_50: G = if unconstrained { Bytes2::validate_inputs(&__v_44, &__v_49)?; Bytes2::less_than(&__v_44, &__v_49) } else { bytes2_less_than_value(__v_44, __v_49, record)? }; let __v_51: G = G::from_u64(1); if (__v_50 != __v_51) { return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_51.as_canonical_u64(), msg: Some("structural join: Merkle path exceeds 64 steps".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_52: G = __loaded[0]; let __v_53: G = __loaded[1]; let __v_54: G = __loaded[2]; @@ -21801,7 +22031,7 @@ fn aiur_fn_228( if (__v_54 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("structural join: trailing bytes after Merkle path".to_string()) }); } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_47, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_47, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(1); if (__v_57 != __v_58) { @@ -21809,7 +22039,7 @@ fn aiur_fn_228( } let __v_59: G = G::from_u64(1); let __ret: [G; OUT_228] = [__v_59]; - record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[228].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -21820,24 +22050,25 @@ const INPUT_SIZE_229: usize = 4; const IN_229: usize = 4; const OUT_229: usize = 0; fn aiur_fn_229( - inp: [G; IN_229], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } }; + record.checkpoint(229); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[224].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i)?; } record.function_queries[224].output_at(__i).to_array::() }, _ => aiur_fn_224(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; let __v_7: G = __r_arr[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_8: G = __loaded[0]; let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; @@ -21853,35 +22084,35 @@ fn aiur_fn_229( 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_229] = []; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[228].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i)?; } record.function_queries[228].output_at(__i).to_array::() }, _ => aiur_fn_228(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_229] = []; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_5, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_6, __v_7, __v_2, __v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, record, io_buffer, __cu)? } }; let __ret: [G; OUT_229] = []; - record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[229].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21902,14 +22133,15 @@ const INPUT_SIZE_230: usize = 1; const IN_230: usize = 1; const OUT_230: usize = 3; fn aiur_fn_230( - inp: [G; IN_230], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(230); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; match __v_1.as_canonical_u64() { @@ -21917,16 +22149,16 @@ fn aiur_fn_230( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __ret: [G; OUT_230] = [__v_3, __v_4, __v_2]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[230].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, 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_230] = [__v_5, __v_3, __v_4]; - record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[230].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -21940,20 +22172,21 @@ const INPUT_SIZE_231: usize = 1; const IN_231: usize = 1; const OUT_231: usize = 3; fn aiur_fn_231( - inp: [G; IN_231], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } }; + record.checkpoint(231); + let __v_0: G = inp.values()[0]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[77].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i)?; } record.function_queries[77].output_at(__i).to_array::() }, _ => aiur_fn_77(__key, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[230].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i)?; } record.function_queries[230].output_at(__i).to_array::() }, _ => aiur_fn_230(__key, 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]; @@ -21961,7 +22194,7 @@ fn aiur_fn_231( if (__v_1 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("join: child claim is not CheckEnv".to_string()) }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_9: G = __loaded[0]; let __v_10: G = __loaded[1]; let __v_11: G = __loaded[2]; @@ -21977,7 +22210,7 @@ fn aiur_fn_231( 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_231] = [__v_3, __v_5, __v_6]; - record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[231].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -21986,26 +22219,27 @@ const INPUT_SIZE_232: usize = 8; const IN_232: usize = 8; const OUT_232: usize = 1; fn aiur_fn_232( - inp: [G; IN_232], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(232); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; let __v_8: G = G::from_u64(4); let __io_pair: (G, G) = { let __key: [G; 8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __info = io_buffer.get_info(__v_8, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_9: G = __io_pair.0; let __v_10: G = __io_pair.1; let __v_11: G = G::from_u64(4); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_11, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -22041,7 +22275,7 @@ fn aiur_fn_232( let __v_44: G = G::from_u64(91); let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); - let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -22052,14 +22286,14 @@ fn aiur_fn_232( let __v_55: G = G::from_u64(0); let __v_56: G = G::from_u64(0); let __v_57: G = G::from_u64(0); - let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_59: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 8] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_12, __v_47, __v_48, __v_49, __v_58, __v_59, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -22189,7 +22423,7 @@ fn aiur_fn_232( 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_232] = [__v_12]; - record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[232].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22198,15 +22432,16 @@ const INPUT_SIZE_233: usize = 2; const IN_233: usize = 2; const OUT_233: usize = 1; fn aiur_fn_233( - inp: [G; IN_233], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } }; + record.checkpoint(233); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[257].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i)?; } record.function_queries[257].output_at(__i).to_array::() }, _ => aiur_fn_257(__key, 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]; @@ -22237,7 +22472,7 @@ fn aiur_fn_233( let __v_29: G = (__v_11 + __v_28); let __v_30: G = (__v_2 + __v_29); let __ret: [G; OUT_233] = [__v_30]; - record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[233].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22246,46 +22481,47 @@ const INPUT_SIZE_234: usize = 2; const IN_234: usize = 2; const OUT_234: usize = 8; fn aiur_fn_234( - inp: [G; IN_234], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + record.checkpoint(234); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_13]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_0, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __ret: [G; OUT_234] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23]; - record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[234].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22294,28 +22530,29 @@ const INPUT_SIZE_235: usize = 16; const IN_235: usize = 16; const OUT_235: usize = 0; fn aiur_fn_235( - inp: [G; IN_235], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(235); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; if (__v_0 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: None }); } @@ -22341,7 +22578,7 @@ fn aiur_fn_235( return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_235] = []; - record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[235].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -22350,20 +22587,21 @@ const INPUT_SIZE_236: usize = 1; const IN_236: usize = 1; const OUT_236: usize = 1; fn aiur_fn_236( - inp: [G; IN_236], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(236); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_4: G = __loaded[0]; let __v_5: G = __loaded[1]; let __v_6: G = __loaded[2]; @@ -22379,7 +22617,7 @@ fn aiur_fn_236( 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_236] = [__v_2]; - record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[236].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -22393,78 +22631,79 @@ const INPUT_SIZE_237: usize = 13; const IN_237: usize = 13; const OUT_237: usize = 1; fn aiur_fn_237( - inp: [G; IN_237], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(237); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; let __v_13: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_12]; let __info = io_buffer.get_info(__v_13, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_14: G = __io_pair.0; let __v_15: G = __io_pair.1; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_17, __v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_19]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_29, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_33, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_37]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_39, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_39, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_47]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_47]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -22474,17 +22713,17 @@ fn aiur_fn_237( let __v_54: G = __r_arr[6]; let __v_55: G = __r_arr[7]; let __v_56: G = __r_arr[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_56]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_58]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[60].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i)?; } record.function_queries[60].output_at(__i).to_array::() }, _ => aiur_fn_60(__key, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; let __v_61: G = __r_arr[2]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_63]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_63]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = G::from_u64(2); @@ -22492,17 +22731,17 @@ fn aiur_fn_237( let __v_67: G = __io_pair.0; let __v_68: G = __io_pair.1; let __v_69: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_69, __v_67, __v_68]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_69, __v_67, __v_68]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_70]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_72, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_72, __v_71]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = __r_arr[1]; match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_0.as_canonical_u64() { _ => { @@ -22510,9 +22749,9 @@ fn aiur_fn_237( _ => { match __v_18.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; match __v_20.as_canonical_u64() { _ => { @@ -22520,7 +22759,7 @@ fn aiur_fn_237( 0u64 => { let __v_78: G = G::from_u64(1); let __v_79: G = G::from_u64(1); - let __v_80: G = { let __values: [G; 3] = [__v_78, __v_79, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = { let __values: [G; 3] = [__v_78, __v_79, __v_79]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_0 [__v_80]; }, 1u64 => { @@ -22532,15 +22771,15 @@ fn aiur_fn_237( } }; let __v_78: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_30, __v_70]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_30, __v_70]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_20, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_20, __v_79]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_78, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_78, __v_80]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_18, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_18, __v_81]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_7, __v_82]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(0); let __v_85: G = G::from_u64(109); @@ -22570,24 +22809,24 @@ fn aiur_fn_237( let __v_109: G = G::from_u64(118); let __v_110: G = G::from_u64(0); let __v_111: G = G::from_u64(48); - let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_113: G = { let __values: [G; 3] = [__v_108, __v_109, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_114: G = { let __values: [G; 3] = [__v_106, __v_107, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_115: G = { let __values: [G; 3] = [__v_104, __v_105, __v_114]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_116: G = { let __values: [G; 3] = [__v_102, __v_103, __v_115]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_117: G = { let __values: [G; 3] = [__v_100, __v_101, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_118: G = { let __values: [G; 3] = [__v_98, __v_99, __v_117]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_119: G = { let __values: [G; 3] = [__v_96, __v_97, __v_118]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_120: G = { let __values: [G; 3] = [__v_94, __v_95, __v_119]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_121: G = { let __values: [G; 3] = [__v_92, __v_93, __v_120]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_122: G = { let __values: [G; 3] = [__v_90, __v_91, __v_121]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_123: G = { let __values: [G; 3] = [__v_88, __v_89, __v_122]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_124: G = { let __values: [G; 3] = [__v_86, __v_87, __v_123]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_125: G = { let __values: [G; 3] = [__v_84, __v_85, __v_124]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_83]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_113: G = { let __values: [G; 3] = [__v_108, __v_109, __v_112]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_114: G = { let __values: [G; 3] = [__v_106, __v_107, __v_113]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_115: G = { let __values: [G; 3] = [__v_104, __v_105, __v_114]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_116: G = { let __values: [G; 3] = [__v_102, __v_103, __v_115]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_117: G = { let __values: [G; 3] = [__v_100, __v_101, __v_116]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_118: G = { let __values: [G; 3] = [__v_98, __v_99, __v_117]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_119: G = { let __values: [G; 3] = [__v_96, __v_97, __v_118]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_120: G = { let __values: [G; 3] = [__v_94, __v_95, __v_119]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_121: G = { let __values: [G; 3] = [__v_92, __v_93, __v_120]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_122: G = { let __values: [G; 3] = [__v_90, __v_91, __v_121]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_123: G = { let __values: [G; 3] = [__v_88, __v_89, __v_122]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_124: G = { let __values: [G; 3] = [__v_86, __v_87, __v_123]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_125: G = { let __values: [G; 3] = [__v_84, __v_85, __v_124]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_126: G = G::from_u64(1); let __v_127: G = G::from_u64(1); - let __v_128: G = { let __values: [G; 3] = [__v_126, __v_127, __v_127]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_125, __v_128]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_128: G = { let __values: [G; 3] = [__v_126, __v_127, __v_127]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_125, __v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, 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]; @@ -22608,17 +22847,17 @@ fn aiur_fn_237( let __v_146: G = __r_arr[17]; let __v_147: G = G::from_u64(1); let __v_148: G = G::from_u64(1); - let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_149]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_149: G = { let __values: [G; 3] = [__v_147, __v_148, __v_148]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_149]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_150: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_150]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_150]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_145, __v_151]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_145, __v_151]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_152: G = __r_arr[0]; let __v_153: G = G::from_u64(1); let __v_154: G = G::from_u64(1); - let __v_155: G = { let __values: [G; 3] = [__v_153, __v_154, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_152, __v_155]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_155: G = { let __values: [G; 3] = [__v_153, __v_154, __v_154]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_152, __v_155]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_156: G = __r_arr[0]; let __v_157: G = __r_arr[1]; let __v_158: G = __r_arr[2]; @@ -22639,26 +22878,26 @@ fn aiur_fn_237( let __v_173: G = __r_arr[17]; let __v_174: G = G::from_u64(1); let __v_175: G = G::from_u64(1); - let __v_176: G = { let __values: [G; 3] = [__v_174, __v_175, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_176]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_176: G = { let __values: [G; 3] = [__v_174, __v_175, __v_175]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_176]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_177: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_177]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_177]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_178: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_172, __v_178]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_172, __v_178]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_179: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_179, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_179, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_180: G = __r_arr[0]; let __v_181: G = G::from_u64(1); let __v_182: G = G::from_u64(1); - let __v_183: G = { let __values: [G; 3] = [__v_181, __v_182, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26, __v_183]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_183: G = { let __values: [G; 3] = [__v_181, __v_182, __v_182]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26, __v_183]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_184: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_180, __v_184]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_180, __v_184]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_185: G = __r_arr[0]; let __v_186: G = G::from_u64(1); let __v_187: G = G::from_u64(1); - let __v_188: G = { let __values: [G; 3] = [__v_186, __v_187, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_185, __v_188]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_188: G = { let __values: [G; 3] = [__v_186, __v_187, __v_187]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_185, __v_188]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; @@ -22677,12 +22916,12 @@ fn aiur_fn_237( let __v_204: G = __r_arr[15]; let __v_205: G = __r_arr[16]; let __v_206: G = __r_arr[17]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_205, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_205, __v_24]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_207: G = __r_arr[0]; let __v_208: G = G::from_u64(1); let __v_209: G = G::from_u64(1); - let __v_210: G = { let __values: [G; 3] = [__v_208, __v_209, __v_209]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_207, __v_210]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_210: G = { let __values: [G; 3] = [__v_208, __v_209, __v_209]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_207, __v_210]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_211: G = __r_arr[0]; let __v_212: G = __r_arr[1]; let __v_213: G = __r_arr[2]; @@ -22871,27 +23110,27 @@ fn aiur_fn_237( let __v_396: G = (__v_219 + __v_395); let __v_397: G = G::from_u64(0); let __v_398: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_397, __v_398, __v_73, __v_249, __v_270, __v_291, __v_312]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_397, __v_398, __v_73, __v_249, __v_270, __v_291, __v_312]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_399: G = __r_arr[0]; let __v_400: G = __r_arr[1]; let __v_401: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_76, __v_77, __v_30, __v_26, __v_62, __v_64, __v_59, __v_60, __v_57, __v_401, __v_399, __v_400, __v_249, __v_270, __v_291, __v_312, __v_333, __v_354, __v_375, __v_396]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_76, __v_77, __v_30, __v_26, __v_62, __v_64, __v_59, __v_60, __v_57, __v_401, __v_399, __v_400, __v_249, __v_270, __v_291, __v_312, __v_333, __v_354, __v_375, __v_396]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_402: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_76]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_403: G = __r_arr[0]; match __v_34.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_404: G = __r_arr[0]; let __v_405: G = G::from_u64(1); let __v_406: G = G::from_u64(1); - let __v_407: G = { let __values: [G; 3] = [__v_405, __v_406, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_407: G = { let __values: [G; 3] = [__v_405, __v_406, __v_406]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() { 0u64 => { break '__mc_1 [__v_407]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_407]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_60, __v_407]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_408: G = __r_arr[0]; break '__mc_1 [__v_408]; }, @@ -22901,18 +23140,18 @@ fn aiur_fn_237( } }; let __v_408: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_408]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_57, __v_408]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_409: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_64, __v_409]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_64, __v_409]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_410: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_62, __v_410]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_62, __v_410]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_411: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_227, __v_411]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_227, __v_411]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_412: G = __r_arr[0]; let __v_413: G = G::from_u64(1); let __v_414: G = G::from_u64(1); - let __v_415: G = { let __values: [G; 3] = [__v_413, __v_414, __v_414]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_412, __v_415]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_415: G = { let __values: [G; 3] = [__v_413, __v_414, __v_414]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_412, __v_415]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_416: G = __r_arr[0]; let __v_417: G = __r_arr[1]; let __v_418: G = __r_arr[2]; @@ -22973,34 +23212,34 @@ fn aiur_fn_237( let __v_473: G = (__v_458 + __v_472); let __v_474: G = (__v_456 + __v_473); let __v_475: G = (__v_424 + __v_474); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_432, __v_34, __v_36, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_432, __v_34, __v_36, __v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_476: G = __r_arr[0]; let __v_477: G = __r_arr[1]; let __v_478: G = G::from_u64(1); let __v_479: G = G::from_u64(1); - let __v_480: G = { let __values: [G; 3] = [__v_478, __v_479, __v_479]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_46, __v_480]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_480: G = { let __values: [G; 3] = [__v_478, __v_479, __v_479]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_46, __v_480]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_481: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_477, __v_481]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_477, __v_481]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_482: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_482, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_482, __v_34]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_483: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_483, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_483, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_484: G = __r_arr[0]; let __v_485: G = __r_arr[1]; let __v_486: G = (__v_404 + __v_0); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_484, __v_485, __v_4, __v_486]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_484, __v_485, __v_4, __v_486]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_487: G = __r_arr[0]; let __v_488: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_40, __v_44, __v_488, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_40, __v_44, __v_488, __v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_489: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_484, __v_485, __v_489, __v_454, __v_475, __v_62, __v_64, __v_57, __v_59, __v_60, __v_20, __v_22, __v_24, __v_78, __v_77, __v_30, __v_375, __v_396, __v_403, __v_0, __v_486, __v_476, __v_34, __v_46, __v_404]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_484, __v_485, __v_489, __v_454, __v_475, __v_62, __v_64, __v_57, __v_59, __v_60, __v_20, __v_22, __v_24, __v_78, __v_77, __v_30, __v_375, __v_396, __v_403, __v_0, __v_486, __v_476, __v_34, __v_46, __v_404]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_490: G = __r_arr[0]; let __v_491: G = (__v_14 + __v_15); if (__v_65 != __v_491) { return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_491.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_74.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_492: G = __loaded[0]; let __v_493: G = __loaded[1]; let __v_494: G = __loaded[2]; @@ -23020,22 +23259,22 @@ fn aiur_fn_237( if (__v_497 != __v_498) { return Err(ExecError::AssertEqMismatch { lhs: __v_497.as_canonical_u64(), rhs: __v_498.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_499: G = __r_arr[0]; if (__v_499 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_499.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_64]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_64]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_500: G = __r_arr[0]; if (__v_500 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_500.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_57]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_57]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_501: G = __r_arr[0]; if (__v_501 != __v_75) { return Err(ExecError::AssertEqMismatch { lhs: __v_501.as_canonical_u64(), rhs: __v_75.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_502: G = __r_arr[0]; let __v_503: G = G::from_u64(1); if (__v_502 != __v_503) { @@ -23058,15 +23297,15 @@ fn aiur_fn_237( if (__v_3 != __v_508) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_508.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_509: G = __r_arr[0]; let __v_510: G = G::from_u64(1); if (__v_509 != __v_510) { return Err(ExecError::AssertEqMismatch { lhs: __v_509.as_canonical_u64(), rhs: __v_510.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_511: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_512: G = __r_arr[0]; let __v_513: G = (__v_511 - __v_512); let __v_514: G = G::from_bool((__v_513 == G::ZERO)); @@ -23074,9 +23313,9 @@ fn aiur_fn_237( if (__v_514 != __v_515) { return Err(ExecError::AssertEqMismatch { lhs: __v_514.as_canonical_u64(), rhs: __v_515.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_76]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_76]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_516: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_517: G = __r_arr[0]; let __v_518: G = (__v_516 - __v_517); let __v_519: G = G::from_bool((__v_518 == G::ZERO)); @@ -23084,7 +23323,7 @@ fn aiur_fn_237( if (__v_519 != __v_520) { return Err(ExecError::AssertEqMismatch { lhs: __v_519.as_canonical_u64(), rhs: __v_520.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_521: G = __r_arr[0]; let __v_522: G = (__v_521 - __v_404); let __v_523: G = G::from_bool((__v_522 == G::ZERO)); @@ -23092,16 +23331,16 @@ fn aiur_fn_237( if (__v_523 != __v_524) { return Err(ExecError::AssertEqMismatch { lhs: __v_523.as_canonical_u64(), rhs: __v_524.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_525: G = __r_arr[0]; let __v_526: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_59, __v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_527: G = __r_arr[0]; let __v_528: G = (__v_526 + __v_527); if (__v_525 != __v_528) { return Err(ExecError::AssertEqMismatch { lhs: __v_525.as_canonical_u64(), rhs: __v_528.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_529: G = __r_arr[0]; let __v_530: G = (__v_529 - __v_404); let __v_531: G = G::from_bool((__v_530 == G::ZERO)); @@ -23109,33 +23348,33 @@ fn aiur_fn_237( if (__v_531 != __v_532) { return Err(ExecError::AssertEqMismatch { lhs: __v_531.as_canonical_u64(), rhs: __v_532.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_533: G = __r_arr[0]; let __v_534: G = G::from_u64(1); if (__v_533 != __v_534) { return Err(ExecError::AssertEqMismatch { lhs: __v_533.as_canonical_u64(), rhs: __v_534.as_canonical_u64(), msg: None }); } let __v_535: G = G::from_u64(33); - let __v_536: G = { let __a_val = __v_486.as_canonical_u64(); let __b_val = __v_535.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_536: G = { let __a_val = __v_486.as_canonical_u64(); let __b_val = __v_535.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_537: G = G::from_u64(1); if (__v_536 != __v_537) { return Err(ExecError::AssertEqMismatch { lhs: __v_536.as_canonical_u64(), rhs: __v_537.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_40, __v_487, __v_20, __v_22, __v_24, __v_78, __v_59, __v_60, __v_77, __v_30, __v_403, __v_0, __v_486]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_40, __v_487, __v_20, __v_22, __v_24, __v_78, __v_59, __v_60, __v_77, __v_30, __v_403, __v_0, __v_486]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_538: G = __r_arr[0]; let __v_539: G = G::from_u64(1); if (__v_538 != __v_539) { return Err(ExecError::AssertEqMismatch { lhs: __v_538.as_canonical_u64(), rhs: __v_539.as_canonical_u64(), msg: None }); } let __v_540: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_44, __v_34, __v_490, __v_487, __v_540, __v_486]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_44, __v_34, __v_490, __v_487, __v_540, __v_486]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_541: G = __r_arr[0]; let __v_542: G = G::from_u64(1); if (__v_541 != __v_542) { return Err(ExecError::AssertEqMismatch { lhs: __v_541.as_canonical_u64(), rhs: __v_542.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_237] = [__v_73]; - record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[237].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23156,16 +23395,17 @@ const INPUT_SIZE_238: usize = 2; const IN_238: usize = 2; const OUT_238: usize = 3; fn aiur_fn_238( - inp: [G; IN_238], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(238); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; let __v_2: G = G::from_u64(10); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_2]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23174,18 +23414,18 @@ fn aiur_fn_238( 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_232] = { let __args: [G; IN_232] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_11]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_13, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_13, __v_12]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_14]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[236].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i)?; } record.function_queries[236].output_at(__i).to_array::() }, _ => aiur_fn_236(__key, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_16, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23194,7 +23434,7 @@ fn aiur_fn_238( let __v_23: G = __r_arr[5]; let __v_24: G = __r_arr[6]; let __v_25: G = __r_arr[7]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_26: G = __loaded[0]; let __v_27: G = __loaded[1]; let __v_28: G = __loaded[2]; @@ -23209,33 +23449,33 @@ fn aiur_fn_238( 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_249] = { let __args: [G; IN_249] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_16]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, 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_233] = { let __args: [G; IN_233] = [__v_16, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_233] = { let __args: [G; IN_233] = [__v_16, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, 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_232] = { let __args: [G; IN_232] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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_238] = [__v_39, __v_40, __v_41]; - record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[238].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -23244,46 +23484,47 @@ const INPUT_SIZE_239: usize = 21; const IN_239: usize = 21; const OUT_239: usize = 3; fn aiur_fn_239( - inp: [G; IN_239], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __v_2: G = inp[2]; - let __v_3: G = inp[3]; - let __v_4: G = inp[4]; - let __v_5: G = inp[5]; - let __v_6: G = inp[6]; - let __v_7: G = inp[7]; - let __v_8: G = inp[8]; - let __v_9: G = inp[9]; - let __v_10: G = inp[10]; - let __v_11: G = inp[11]; - let __v_12: G = inp[12]; - let __v_13: G = inp[13]; - let __v_14: G = inp[14]; - let __v_15: G = inp[15]; - let __v_16: G = inp[16]; - let __v_17: G = inp[17]; - let __v_18: G = inp[18]; - let __v_19: G = inp[19]; - let __v_20: G = inp[20]; - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } }; + record.checkpoint(239); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; + let __v_16: G = inp.values()[16]; + let __v_17: G = inp.values()[17]; + let __v_18: G = inp.values()[18]; + let __v_19: G = inp.values()[19]; + let __v_20: G = inp.values()[20]; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[236].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i)?; } record.function_queries[236].output_at(__i).to_array::() }, _ => aiur_fn_236(__key, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(18); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("join: recursive child claim must contain 16 public inputs".to_string()) }); } let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[233].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i)?; } record.function_queries[233].output_at(__i).to_array::() }, _ => aiur_fn_233(__key, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(0); if (__v_27 != __v_28) { @@ -23294,7 +23535,7 @@ fn aiur_fn_239( match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21, __v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23303,13 +23544,13 @@ fn aiur_fn_239( 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_235] = { let __args: [G; IN_235] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_21, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_21, __v_17]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[238].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i)?; } record.function_queries[238].output_at(__i).to_array::() }, _ => aiur_fn_238(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; let __ret: [G; OUT_239] = [__v_40, __v_41, __v_42]; - record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -23328,7 +23569,7 @@ fn aiur_fn_239( } }; let __v_33: G = G::from_u64(2); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21, __v_33]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23337,9 +23578,9 @@ fn aiur_fn_239( 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_235] = { let __args: [G; IN_235] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[235].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i)?; } record.function_queries[235].output_at(__i).to_array::() }, _ => aiur_fn_235(__key, record, io_buffer, __cu)? } }; let __v_42: G = G::from_u64(10); - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_21, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[234].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i)?; } record.function_queries[234].output_at(__i).to_array::() }, _ => aiur_fn_234(__key, 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]; @@ -23348,14 +23589,14 @@ fn aiur_fn_239( 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_232] = { let __args: [G; IN_232] = [__v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[232].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i)?; } record.function_queries[232].output_at(__i).to_array::() }, _ => aiur_fn_232(__key, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_51]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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_239] = [__v_52, __v_53, __v_54]; - record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[239].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, } @@ -23366,35 +23607,36 @@ const INPUT_SIZE_240: usize = 16; const IN_240: usize = 16; const OUT_240: usize = 0; fn aiur_fn_240( - inp: [G; IN_240], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(240); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(3); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -23430,7 +23672,7 @@ fn aiur_fn_240( let __v_53: G = G::from_u64(91); let __v_54: G = G::from_u64(1); let __v_55: G = G::from_u64(1); - let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -23441,14 +23683,14 @@ fn aiur_fn_240( let __v_64: G = G::from_u64(0); let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -23481,109 +23723,109 @@ fn aiur_fn_240( 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_207] = { let __args: [G; IN_207] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_122]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_122]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_133: G = __r_arr[0]; let __v_134: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_135: G = __r_arr[0]; let __v_136: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_140]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_140]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_142]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_142]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_143: G = __r_arr[0]; let __v_144: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_144]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_144]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_145: G = __r_arr[0]; let __v_146: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_146]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_146]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_148]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_148]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_149: G = __r_arr[0]; let __v_150: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_150]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_150]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_152]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_152]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_153: G = __r_arr[0]; let __v_154: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_154]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_154]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_156]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_156]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_158]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_158]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_159: G = __r_arr[0]; let __v_160: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_160]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_160]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_161: G = __r_arr[0]; let __v_162: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_162]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_162]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_164]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_164]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; let __v_166: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_166]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_166]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_168]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_168]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_169: G = __r_arr[0]; let __v_170: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_170]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_170]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_171: G = __r_arr[0]; let __v_172: G = __r_arr[1]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, 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]; @@ -23592,7 +23834,7 @@ fn aiur_fn_240( 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_209] = { let __args: [G; IN_209] = [__v_123]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_123]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, 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]; @@ -23601,13 +23843,13 @@ fn aiur_fn_240( let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_189: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_190: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, 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); @@ -23615,7 +23857,7 @@ fn aiur_fn_240( let __v_195: G = __io_pair.0; let __v_196: G = __io_pair.1; let __v_197: G = G::from_u64(1); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_197, __v_195, __v_196]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_197, __v_195, __v_196]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -23651,7 +23893,7 @@ fn aiur_fn_240( let __v_230: G = G::from_u64(91); let __v_231: G = G::from_u64(1); let __v_232: G = G::from_u64(1); - let __v_233: G = { let __values: [G; 3] = [__v_231, __v_232, __v_232]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_233: G = { let __values: [G; 3] = [__v_231, __v_232, __v_232]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -23662,14 +23904,14 @@ fn aiur_fn_240( let __v_241: G = G::from_u64(0); let __v_242: G = G::from_u64(0); let __v_243: G = G::from_u64(0); - let __v_244: G = { let __values: [G; 8] = [__v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_245: G = { let __values: [G; 32] = [__v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_244: G = { let __values: [G; 8] = [__v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_198, __v_233, __v_234, __v_235, __v_244, __v_245, __v_248]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_249: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -23702,7 +23944,7 @@ fn aiur_fn_240( let __v_279: G = __r_arr[29]; let __v_280: G = __r_arr[30]; let __v_281: G = __r_arr[31]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23713,7 +23955,7 @@ fn aiur_fn_240( let __v_289: G = __r_arr[7]; let __v_290: G = __r_arr[8]; let __v_291: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_291]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_291]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23724,7 +23966,7 @@ fn aiur_fn_240( let __v_299: G = __r_arr[7]; let __v_300: G = __r_arr[8]; let __v_301: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_301]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_301]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23735,7 +23977,7 @@ fn aiur_fn_240( let __v_309: G = __r_arr[7]; let __v_310: G = __r_arr[8]; let __v_311: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_311]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_311]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23746,7 +23988,7 @@ fn aiur_fn_240( let __v_319: G = __r_arr[7]; let __v_320: G = __r_arr[8]; let __v_321: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_321]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_321]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23757,7 +23999,7 @@ fn aiur_fn_240( let __v_329: G = __r_arr[7]; let __v_330: G = __r_arr[8]; let __v_331: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_331]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_331]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23768,7 +24010,7 @@ fn aiur_fn_240( let __v_339: G = __r_arr[7]; let __v_340: G = __r_arr[8]; let __v_341: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_341]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_341]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23788,15 +24030,15 @@ fn aiur_fn_240( let __v_358: G = G::from_u64(0); let __v_359: G = G::from_u64(1); let __v_360: G = G::from_u64(1); - let __v_361: G = { let __values: [G; 10] = [__v_359, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_362: G = { let __values: [G; 10] = [__v_358, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_361]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_363: G = { let __values: [G; 10] = [__v_357, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_362]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_364: G = { let __values: [G; 10] = [__v_356, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_363]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_365: G = { let __values: [G; 10] = [__v_355, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_320, __v_364]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_366: G = { let __values: [G; 10] = [__v_354, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_365]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_367: G = { let __values: [G; 10] = [__v_353, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_366]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_368: G = { let __values: [G; 10] = [__v_352, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_367]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -23807,32 +24049,32 @@ fn aiur_fn_240( let __v_376: G = __r_arr[7]; let __v_377: G = __r_arr[8]; let __v_378: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_378, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_378, __v_369]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_379: G = __r_arr[0]; let __v_380: G = __r_arr[1]; let __v_381: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_381]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_381]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[94].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i)?; } record.function_queries[94].output_at(__i).to_array::() }, _ => aiur_fn_94(__key, record, io_buffer, __cu)? } }; let __v_382: G = __r_arr[0]; let __v_383: G = __r_arr[1]; let __v_384: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_385: G = __r_arr[0]; let __v_386: G = __r_arr[1]; let __v_387: G = G::from_u64(0); - let __v_388: G = { let __values: [G; 10] = [__v_387, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_368, __v_388]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_368, __v_388]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_389: G = __r_arr[0]; let __v_390: G = G::from_u64(0); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_390]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[237].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i)?; } record.function_queries[237].output_at(__i).to_array::() }, _ => aiur_fn_237(__key, record, io_buffer, __cu)? } }; let __v_391: G = __r_arr[0]; let __v_392: G = G::from_u64(1); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_392]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[237].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i)?; } record.function_queries[237].output_at(__i).to_array::() }, _ => aiur_fn_237(__key, record, io_buffer, __cu)? } }; let __v_393: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_391, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, 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_239] = { let __args: [G; IN_239] = [__v_393, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, 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]; @@ -23842,7 +24084,7 @@ fn aiur_fn_240( let __v_402: G = __io_pair.0; let __v_403: G = __io_pair.1; let __v_404: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -23878,7 +24120,7 @@ fn aiur_fn_240( let __v_437: G = G::from_u64(91); let __v_438: G = G::from_u64(1); let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -23889,14 +24131,14 @@ fn aiur_fn_240( let __v_448: G = G::from_u64(0); let __v_449: G = G::from_u64(0); let __v_450: G = G::from_u64(0); - let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -23929,24 +24171,24 @@ fn aiur_fn_240( 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_231] = { let __args: [G; IN_231] = [__v_405]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_405]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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_220] = { let __args: [G; IN_220] = [__v_394]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_394]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_492: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_397]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_397]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_493: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_395, __v_396]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_395, __v_396]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_494: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_398, __v_399]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_398, __v_399]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_495: G = __r_arr[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_489]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_489]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[220].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i)?; } record.function_queries[220].output_at(__i).to_array::() }, _ => aiur_fn_220(__key, record, io_buffer, __cu)? } }; let __v_496: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_490, __v_491]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_490, __v_491]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_497: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_492, __v_493, __v_496]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_494, __v_495, __v_496, __v_497]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_492, __v_493, __v_496]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[223].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i)?; } record.function_queries[223].output_at(__i).to_array::() }, _ => aiur_fn_223(__key, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_494, __v_495, __v_496, __v_497]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[226].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i)?; } record.function_queries[226].output_at(__i).to_array::() }, _ => aiur_fn_226(__key, 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()) }); @@ -24047,7 +24289,7 @@ fn aiur_fn_240( 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_172.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_571: G = __loaded[0]; let __v_572: G = __loaded[1]; let __v_573: G = __loaded[2]; @@ -24158,7 +24400,7 @@ fn aiur_fn_240( 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_386.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_648: G = __loaded[0]; let __v_649: G = __loaded[1]; let __v_650: G = __loaded[2]; @@ -24270,7 +24512,7 @@ fn aiur_fn_240( 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_240] = []; - record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[240].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -24279,35 +24521,36 @@ const INPUT_SIZE_241: usize = 16; const IN_241: usize = 16; const OUT_241: usize = 0; fn aiur_fn_241( - inp: [G; IN_241], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __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]; + record.checkpoint(241); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; let __v_16: G = G::from_u64(3); let __v_17: G = G::from_u64(0); let __io_pair: (G, G) = { let __key: [G; 1] = [__v_17]; let __info = io_buffer.get_info(__v_16, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_18: G = __io_pair.0; let __v_19: G = __io_pair.1; let __v_20: G = G::from_u64(3); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_20, __v_18, __v_19]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -24343,7 +24586,7 @@ fn aiur_fn_241( let __v_53: G = G::from_u64(91); let __v_54: G = G::from_u64(1); let __v_55: G = G::from_u64(1); - let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -24354,14 +24597,14 @@ fn aiur_fn_241( let __v_64: G = G::from_u64(0); let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); - let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_68: G = { let __values: [G; 32] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 8] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_21, __v_56, __v_57, __v_58, __v_67, __v_68, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_72]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -24394,109 +24637,109 @@ fn aiur_fn_241( 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_207] = { let __args: [G; IN_207] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_21]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_106]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_107: G = __r_arr[0]; let __v_108: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_108]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_109: G = __r_arr[0]; let __v_110: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_110]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_111: G = __r_arr[0]; let __v_112: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_112]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_113: G = __r_arr[0]; let __v_114: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_114]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_116]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_117: G = __r_arr[0]; let __v_118: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_118]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_120]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; let __v_122: G = __r_arr[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_122]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_122]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[207].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i)?; } record.function_queries[207].output_at(__i).to_array::() }, _ => aiur_fn_207(__key, record, io_buffer, __cu)? } }; let __v_123: G = __r_arr[0]; let __v_124: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_124]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_125: G = __r_arr[0]; let __v_126: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_126]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_128]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_129: G = __r_arr[0]; let __v_130: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_130]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_132]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_133: G = __r_arr[0]; let __v_134: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_134]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_135: G = __r_arr[0]; let __v_136: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_136]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_137: G = __r_arr[0]; let __v_138: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_138]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_139: G = __r_arr[0]; let __v_140: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_140]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_140]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_141: G = __r_arr[0]; let __v_142: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_142]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_142]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_143: G = __r_arr[0]; let __v_144: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_144]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_144]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_145: G = __r_arr[0]; let __v_146: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_146]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_146]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_147: G = __r_arr[0]; let __v_148: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_148]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_148]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_149: G = __r_arr[0]; let __v_150: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_150]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_150]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_152]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_152]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_153: G = __r_arr[0]; let __v_154: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_154]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_154]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_155: G = __r_arr[0]; let __v_156: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_156]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_156]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_157: G = __r_arr[0]; let __v_158: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_158]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_158]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_159: G = __r_arr[0]; let __v_160: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_160]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_160]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_161: G = __r_arr[0]; let __v_162: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_162]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_162]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_163: G = __r_arr[0]; let __v_164: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_164]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_164]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_165: G = __r_arr[0]; let __v_166: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_166]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_166]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_167: G = __r_arr[0]; let __v_168: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_168]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_168]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_169: G = __r_arr[0]; let __v_170: G = __r_arr[1]; - let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_170]; let __cu = unconstrained; let __hit = record.function_queries[25].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i); } let __ret: [G; OUT_25] = unsafe { *(record.function_queries[25].output_at(__i).as_ptr() as *const [G; OUT_25]) }; __ret }, _ => aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_25] = { let __args: [G; IN_25] = [__v_170]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[25].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[25].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[25].bump_multiplicity(__i)?; } record.function_queries[25].output_at(__i).to_array::() }, _ => aiur_fn_25(__key, record, io_buffer, __cu)? } }; let __v_171: G = __r_arr[0]; let __v_172: G = __r_arr[1]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_105]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_105]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, 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]; @@ -24505,7 +24748,7 @@ fn aiur_fn_241( 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_209] = { let __args: [G; IN_209] = [__v_123]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_123]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[209].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i)?; } record.function_queries[209].output_at(__i).to_array::() }, _ => aiur_fn_209(__key, 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]; @@ -24514,13 +24757,13 @@ fn aiur_fn_241( let __v_186: G = __r_arr[5]; let __v_187: G = __r_arr[6]; let __v_188: G = __r_arr[7]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_107, __v_109, __v_111, __v_113, __v_115, __v_117, __v_119, __v_121]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_189: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_125, __v_127, __v_129, __v_131, __v_133, __v_135, __v_137, __v_139]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_190: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_141, __v_143, __v_145, __v_147, __v_149, __v_151, __v_153, __v_155]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; - let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_157, __v_159, __v_161, __v_163, __v_165, __v_167, __v_169, __v_171]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[13].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i)?; } record.function_queries[13].output_at(__i).to_array::() }, _ => aiur_fn_13(__key, 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); @@ -24528,7 +24771,7 @@ fn aiur_fn_241( let __v_195: G = __io_pair.0; let __v_196: G = __io_pair.1; let __v_197: G = G::from_u64(1); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_197, __v_195, __v_196]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_197, __v_195, __v_196]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -24564,7 +24807,7 @@ fn aiur_fn_241( let __v_230: G = G::from_u64(91); let __v_231: G = G::from_u64(1); let __v_232: G = G::from_u64(1); - let __v_233: G = { let __values: [G; 3] = [__v_231, __v_232, __v_232]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_233: G = { let __values: [G; 3] = [__v_231, __v_232, __v_232]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -24575,14 +24818,14 @@ fn aiur_fn_241( let __v_241: G = G::from_u64(0); let __v_242: G = G::from_u64(0); let __v_243: G = G::from_u64(0); - let __v_244: G = { let __values: [G; 8] = [__v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_245: G = { let __values: [G; 32] = [__v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_244: G = { let __values: [G; 8] = [__v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_198, __v_233, __v_234, __v_235, __v_244, __v_245, __v_248]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_249: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_249]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -24615,7 +24858,7 @@ fn aiur_fn_241( let __v_279: G = __r_arr[29]; let __v_280: G = __r_arr[30]; let __v_281: G = __r_arr[31]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24626,7 +24869,7 @@ fn aiur_fn_241( let __v_289: G = __r_arr[7]; let __v_290: G = __r_arr[8]; let __v_291: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_291]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_291]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24637,7 +24880,7 @@ fn aiur_fn_241( let __v_299: G = __r_arr[7]; let __v_300: G = __r_arr[8]; let __v_301: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_301]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_301]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24648,7 +24891,7 @@ fn aiur_fn_241( let __v_309: G = __r_arr[7]; let __v_310: G = __r_arr[8]; let __v_311: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_311]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_311]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24659,7 +24902,7 @@ fn aiur_fn_241( let __v_319: G = __r_arr[7]; let __v_320: G = __r_arr[8]; let __v_321: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_321]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_321]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24670,7 +24913,7 @@ fn aiur_fn_241( let __v_329: G = __r_arr[7]; let __v_330: G = __r_arr[8]; let __v_331: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_331]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_331]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24681,7 +24924,7 @@ fn aiur_fn_241( let __v_339: G = __r_arr[7]; let __v_340: G = __r_arr[8]; let __v_341: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_341]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_341]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24701,15 +24944,15 @@ fn aiur_fn_241( let __v_358: G = G::from_u64(0); let __v_359: G = G::from_u64(1); let __v_360: G = G::from_u64(1); - let __v_361: G = { let __values: [G; 10] = [__v_359, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360, __v_360]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_362: G = { let __values: [G; 10] = [__v_358, __v_343, __v_344, __v_345, __v_346, __v_347, __v_348, __v_349, __v_350, __v_361]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_363: G = { let __values: [G; 10] = [__v_357, __v_333, __v_334, __v_335, __v_336, __v_337, __v_338, __v_339, __v_340, __v_362]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_364: G = { let __values: [G; 10] = [__v_356, __v_323, __v_324, __v_325, __v_326, __v_327, __v_328, __v_329, __v_330, __v_363]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_365: G = { let __values: [G; 10] = [__v_355, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_320, __v_364]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_366: G = { let __values: [G; 10] = [__v_354, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_365]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_367: G = { let __values: [G; 10] = [__v_353, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_366]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_368: G = { let __values: [G; 10] = [__v_352, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_367]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_351]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, 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]; @@ -24720,32 +24963,32 @@ fn aiur_fn_241( let __v_376: G = __r_arr[7]; let __v_377: G = __r_arr[8]; let __v_378: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_378, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_378, __v_369]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_379: G = __r_arr[0]; let __v_380: G = __r_arr[1]; let __v_381: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_381]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_381]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[94].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i)?; } record.function_queries[94].output_at(__i).to_array::() }, _ => aiur_fn_94(__key, record, io_buffer, __cu)? } }; let __v_382: G = __r_arr[0]; let __v_383: G = __r_arr[1]; let __v_384: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_384, __v_369]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_385: G = __r_arr[0]; let __v_386: G = __r_arr[1]; let __v_387: G = G::from_u64(0); - let __v_388: G = { let __values: [G; 10] = [__v_387, __v_370, __v_371, __v_372, __v_373, __v_374, __v_375, __v_376, __v_377, __v_380]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_368, __v_388]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_368, __v_388]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_389: G = __r_arr[0]; let __v_390: G = G::from_u64(0); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_390]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[237].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i)?; } record.function_queries[237].output_at(__i).to_array::() }, _ => aiur_fn_237(__key, record, io_buffer, __cu)? } }; let __v_391: G = __r_arr[0]; let __v_392: G = G::from_u64(1); - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_282, __v_292, __v_302, __v_312, __v_322, __v_332, __v_342, __v_389, __v_379, __v_382, __v_383, __v_385, __v_392]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[237].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i)?; } record.function_queries[237].output_at(__i).to_array::() }, _ => aiur_fn_237(__key, record, io_buffer, __cu)? } }; let __v_393: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_391, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, 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_239] = { let __args: [G; IN_239] = [__v_393, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_189, __v_190, __v_191, __v_192]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[239].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i)?; } record.function_queries[239].output_at(__i).to_array::() }, _ => aiur_fn_239(__key, 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]; @@ -24755,7 +24998,7 @@ fn aiur_fn_241( let __v_402: G = __io_pair.0; let __v_403: G = __io_pair.1; let __v_404: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_404, __v_402, __v_403]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, 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); @@ -24791,7 +25034,7 @@ fn aiur_fn_241( let __v_437: G = G::from_u64(91); let __v_438: G = G::from_u64(1); let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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); @@ -24802,14 +25045,14 @@ fn aiur_fn_241( let __v_448: G = G::from_u64(0); let __v_449: G = G::from_u64(0); let __v_450: G = G::from_u64(0); - let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_452: G = { let __values: [G; 32] = [__v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_451: G = { let __values: [G; 8] = [__v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_449, __v_450]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_405, __v_440, __v_441, __v_442, __v_451, __v_452, __v_455]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_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 __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__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 __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_456: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_456]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, 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]; @@ -24842,19 +25085,19 @@ fn aiur_fn_241( 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_231] = { let __args: [G; IN_231] = [__v_405]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_405]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[231].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i)?; } record.function_queries[231].output_at(__i).to_array::() }, _ => aiur_fn_231(__key, 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_210] = { let __args: [G; IN_210] = [__v_394, __v_397]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_394, __v_397]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[210].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i)?; } record.function_queries[210].output_at(__i).to_array::() }, _ => aiur_fn_210(__key, record, io_buffer, __cu)? } }; let __v_492: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_395, __v_396]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_395, __v_396]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_493: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_398, __v_399]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_398, __v_399]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_494: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_490, __v_491]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_490, __v_491]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[221].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i)?; } record.function_queries[221].output_at(__i).to_array::() }, _ => aiur_fn_221(__key, record, io_buffer, __cu)? } }; let __v_495: G = __r_arr[0]; - let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_493, __v_494, __v_489, __v_495]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_493, __v_494, __v_489, __v_495]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[229].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i)?; } record.function_queries[229].output_at(__i).to_array::() }, _ => aiur_fn_229(__key, 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()) }); @@ -24955,7 +25198,7 @@ fn aiur_fn_241( 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_172.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_569: G = __loaded[0]; let __v_570: G = __loaded[1]; let __v_571: G = __loaded[2]; @@ -25066,7 +25309,7 @@ fn aiur_fn_241( 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_386.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_646: G = __loaded[0]; let __v_647: G = __loaded[1]; let __v_648: G = __loaded[2]; @@ -25177,14 +25420,14 @@ fn aiur_fn_241( if (__v_722 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_722.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("structural join: output claim digest mismatch".to_string()) }); } - let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_489, __v_492]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_489, __v_492]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[2].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i)?; } record.function_queries[2].output_at(__i).to_array::() }, _ => aiur_fn_2(__key, 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_241] = []; - record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[241].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -25193,82 +25436,83 @@ const INPUT_SIZE_242: usize = 16; const IN_242: usize = 16; const OUT_242: usize = 0; fn aiur_fn_242( - inp: [G; IN_242], + inp: QueryKey, 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]; - let __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]; + record.checkpoint(242); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __v_2: G = inp.values()[2]; + let __v_3: G = inp.values()[3]; + let __v_4: G = inp.values()[4]; + let __v_5: G = inp.values()[5]; + let __v_6: G = inp.values()[6]; + let __v_7: G = inp.values()[7]; + let __v_8: G = inp.values()[8]; + let __v_9: G = inp.values()[9]; + let __v_10: G = inp.values()[10]; + let __v_11: G = inp.values()[11]; + let __v_12: G = inp.values()[12]; + let __v_13: G = inp.values()[13]; + let __v_14: G = inp.values()[14]; + let __v_15: G = inp.values()[15]; let __v_16: G = G::from_u64(0); 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 __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_18]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_21, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_21, __v_20]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_23]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_25]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[39].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i); } let __ret: [G; OUT_39] = unsafe { *(record.function_queries[39].output_at(__i).as_ptr() as *const [G; OUT_39]) }; __ret }, _ => aiur_fn_39(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_27]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[39].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[39].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[39].bump_multiplicity(__i)?; } record.function_queries[39].output_at(__i).to_array::() }, _ => aiur_fn_39(__key, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_29]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_31]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_33, __v_32]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[34].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i)?; } record.function_queries[34].output_at(__i).to_array::() }, _ => aiur_fn_34(__key, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_35]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; - let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_37, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_37, __v_36]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[51].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i)?; } record.function_queries[51].output_at(__i).to_array::() }, _ => aiur_fn_51(__key, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[35].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i); } let __ret: [G; OUT_35] = unsafe { *(record.function_queries[35].output_at(__i).as_ptr() as *const [G; OUT_35]) }; __ret }, _ => aiur_fn_35(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__v_39]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[35].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[35].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[35].bump_multiplicity(__i)?; } record.function_queries[35].output_at(__i).to_array::() }, _ => aiur_fn_35(__key, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_41]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = __r_arr[1]; - let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_42]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[55].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i)?; } record.function_queries[55].output_at(__i).to_array::() }, _ => aiur_fn_55(__key, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[30].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i); } let __ret: [G; OUT_30] = unsafe { *(record.function_queries[30].output_at(__i).as_ptr() as *const [G; OUT_30]) }; __ret }, _ => aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_45]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[30].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[30].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[30].bump_multiplicity(__i)?; } record.function_queries[30].output_at(__i).to_array::() }, _ => aiur_fn_30(__key, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_47, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_47, __v_46]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[58].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i)?; } record.function_queries[58].output_at(__i).to_array::() }, _ => aiur_fn_58(__key, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; - let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_49]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_49]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[37].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i)?; } record.function_queries[37].output_at(__i).to_array::() }, _ => aiur_fn_37(__key, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; - let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_51]; let __cu = true; let __hit = record.function_queries[29].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_29] = unsafe { *(record.function_queries[29].output_at(__i).as_ptr() as *const [G; OUT_29]) }; __ret }, _ => aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_51]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[29].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[29].output_at(__i).to_array::() }, _ => aiur_fn_29(__key, 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]; @@ -25278,17 +25522,17 @@ fn aiur_fn_242( let __v_58: G = __r_arr[6]; let __v_59: G = __r_arr[7]; let __v_60: G = __r_arr[8]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_60]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; - let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_62]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[60].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i)?; } record.function_queries[60].output_at(__i).to_array::() }, _ => aiur_fn_60(__key, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = __r_arr[2]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_65]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_65]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; - let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_67]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[47].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i)?; } record.function_queries[47].output_at(__i).to_array::() }, _ => aiur_fn_47(__key, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = G::from_u64(1); @@ -25297,7 +25541,7 @@ fn aiur_fn_242( let __v_72: G = __io_pair.0; let __v_73: G = __io_pair.1; let __v_74: G = G::from_u64(1); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_74, __v_72, __v_73]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_74, __v_72, __v_73]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __v_76: G = G::from_u64(103); let __v_77: G = G::from_u64(230); @@ -25333,7 +25577,7 @@ fn aiur_fn_242( let __v_107: G = G::from_u64(91); let __v_108: G = G::from_u64(1); let __v_109: G = G::from_u64(1); - let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_110: G = { let __values: [G; 3] = [__v_108, __v_109, __v_109]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_111: G = G::from_u64(0); let __v_112: G = G::from_u64(0); let __v_113: G = G::from_u64(0); @@ -25344,14 +25588,14 @@ fn aiur_fn_242( let __v_118: G = G::from_u64(0); let __v_119: G = G::from_u64(0); let __v_120: G = G::from_u64(0); - let __v_121: G = { let __values: [G; 8] = [__v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_122: G = { let __values: [G; 32] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_121: G = { let __values: [G; 8] = [__v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_122: G = { let __values: [G; 32] = [__v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_123: G = G::from_u64(1); let __v_124: G = G::from_u64(1); - let __v_125: G = { let __values: [G; 34] = [__v_123, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_75, __v_110, __v_111, __v_112, __v_121, __v_122, __v_125]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_125: G = { let __values: [G; 34] = [__v_123, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124, __v_124]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_75, __v_110, __v_111, __v_112, __v_121, __v_122, __v_125]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_126: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_126]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_126]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, record, io_buffer, __cu)? } }; let __v_127: G = __r_arr[0]; let __v_128: G = __r_arr[1]; let __v_129: G = __r_arr[2]; @@ -25384,7 +25628,7 @@ fn aiur_fn_242( let __v_156: G = __r_arr[29]; let __v_157: G = __r_arr[30]; let __v_158: G = __r_arr[31]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_75]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_75]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_159: G = __r_arr[0]; let __v_160: G = __r_arr[1]; let __v_161: G = __r_arr[2]; @@ -25395,7 +25639,7 @@ fn aiur_fn_242( let __v_166: G = __r_arr[7]; let __v_167: G = __r_arr[8]; let __v_168: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_168]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_168]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_169: G = __r_arr[0]; let __v_170: G = __r_arr[1]; let __v_171: G = __r_arr[2]; @@ -25406,7 +25650,7 @@ fn aiur_fn_242( let __v_176: G = __r_arr[7]; let __v_177: G = __r_arr[8]; let __v_178: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_178]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_178]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_179: G = __r_arr[0]; let __v_180: G = __r_arr[1]; let __v_181: G = __r_arr[2]; @@ -25417,7 +25661,7 @@ fn aiur_fn_242( let __v_186: G = __r_arr[7]; let __v_187: G = __r_arr[8]; let __v_188: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_188]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_188]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_189: G = __r_arr[0]; let __v_190: G = __r_arr[1]; let __v_191: G = __r_arr[2]; @@ -25428,7 +25672,7 @@ fn aiur_fn_242( let __v_196: G = __r_arr[7]; let __v_197: G = __r_arr[8]; let __v_198: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_198]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_199: G = __r_arr[0]; let __v_200: G = __r_arr[1]; let __v_201: G = __r_arr[2]; @@ -25439,7 +25683,7 @@ fn aiur_fn_242( let __v_206: G = __r_arr[7]; let __v_207: G = __r_arr[8]; let __v_208: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_208]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_208]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_209: G = __r_arr[0]; let __v_210: G = __r_arr[1]; let __v_211: G = __r_arr[2]; @@ -25450,7 +25694,7 @@ fn aiur_fn_242( let __v_216: G = __r_arr[7]; let __v_217: G = __r_arr[8]; let __v_218: G = __r_arr[9]; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_218]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_218]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_219: G = __r_arr[0]; let __v_220: G = __r_arr[1]; let __v_221: G = __r_arr[2]; @@ -25470,15 +25714,15 @@ fn aiur_fn_242( let __v_235: G = G::from_u64(0); let __v_236: G = G::from_u64(1); let __v_237: G = G::from_u64(1); - let __v_238: G = { let __values: [G; 10] = [__v_236, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_239: G = { let __values: [G; 10] = [__v_235, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_238]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_240: G = { let __values: [G; 10] = [__v_234, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_239]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_241: G = { let __values: [G; 10] = [__v_233, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_240]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_242: G = { let __values: [G; 10] = [__v_232, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_241]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_243: G = { let __values: [G; 10] = [__v_231, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_242]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_244: G = { let __values: [G; 10] = [__v_230, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_243]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_245: G = { let __values: [G; 10] = [__v_229, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_244]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_228]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_238: G = { let __values: [G; 10] = [__v_236, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237, __v_237]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_239: G = { let __values: [G; 10] = [__v_235, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_238]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_240: G = { let __values: [G; 10] = [__v_234, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_239]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_241: G = { let __values: [G; 10] = [__v_233, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_240]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_242: G = { let __values: [G; 10] = [__v_232, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_241]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_243: G = { let __values: [G; 10] = [__v_231, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_242]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_244: G = { let __values: [G; 10] = [__v_230, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_243]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_245: G = { let __values: [G; 10] = [__v_229, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_244]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_228]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[80].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i)?; } record.function_queries[80].output_at(__i).to_array::() }, _ => aiur_fn_80(__key, record, io_buffer, __cu)? } }; let __v_246: G = __r_arr[0]; let __v_247: G = __r_arr[1]; let __v_248: G = __r_arr[2]; @@ -25489,20 +25733,20 @@ fn aiur_fn_242( let __v_253: G = __r_arr[7]; let __v_254: G = __r_arr[8]; let __v_255: G = __r_arr[9]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_255, __v_246]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_255, __v_246]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[93].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i)?; } record.function_queries[93].output_at(__i).to_array::() }, _ => aiur_fn_93(__key, record, io_buffer, __cu)? } }; let __v_256: G = __r_arr[0]; let __v_257: G = __r_arr[1]; let __v_258: G = __r_arr[2]; - let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_258]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_258]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[94].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i)?; } record.function_queries[94].output_at(__i).to_array::() }, _ => aiur_fn_94(__key, record, io_buffer, __cu)? } }; let __v_259: G = __r_arr[0]; let __v_260: G = __r_arr[1]; let __v_261: G = __r_arr[2]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_261, __v_246]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_261, __v_246]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[95].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i)?; } record.function_queries[95].output_at(__i).to_array::() }, _ => aiur_fn_95(__key, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; let __v_263: G = __r_arr[1]; let __v_264: G = G::from_u64(0); - let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_245, __v_265]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_265: G = { let __values: [G; 10] = [__v_264, __v_247, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_257]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_245, __v_265]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_266: G = __r_arr[0]; let __v_267: G = G::from_u64(2); let __v_268: G = G::from_u64(0); @@ -25510,7 +25754,7 @@ fn aiur_fn_242( let __v_269: G = __io_pair.0; let __v_270: G = __io_pair.1; let __v_271: G = G::from_u64(2); - let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_271, __v_269, __v_270]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_271, __v_269, __v_270]; let __key = QueryKey::new(__args); let __cu = true; let __hit = record.function_queries[3].get_prehashed(&__key); match __hit { Some(__i) if true => { record.function_queries[3].output_at(__i).to_array::() }, _ => aiur_fn_3(__key, record, io_buffer, __cu)? } }; let __v_272: G = __r_arr[0]; let __v_273: G = G::from_u64(103); let __v_274: G = G::from_u64(230); @@ -25546,7 +25790,7 @@ fn aiur_fn_242( let __v_304: G = G::from_u64(91); let __v_305: G = G::from_u64(1); let __v_306: G = G::from_u64(1); - let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_307: G = { let __values: [G; 3] = [__v_305, __v_306, __v_306]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_308: G = G::from_u64(0); let __v_309: G = G::from_u64(0); let __v_310: G = G::from_u64(0); @@ -25557,14 +25801,14 @@ fn aiur_fn_242( let __v_315: G = G::from_u64(0); let __v_316: G = G::from_u64(0); let __v_317: G = G::from_u64(0); - let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_319: G = { let __values: [G; 32] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_318: G = { let __values: [G; 8] = [__v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_319: G = { let __values: [G; 32] = [__v_273, __v_274, __v_275, __v_276, __v_277, __v_278, __v_279, __v_280, __v_281, __v_282, __v_283, __v_284, __v_285, __v_286, __v_287, __v_288, __v_289, __v_290, __v_291, __v_292, __v_293, __v_294, __v_295, __v_296, __v_297, __v_298, __v_299, __v_300, __v_301, __v_302, __v_303, __v_304]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_320: G = G::from_u64(1); let __v_321: G = G::from_u64(1); - let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_322: G = { let __values: [G; 34] = [__v_320, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321, __v_321]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_272, __v_307, __v_308, __v_309, __v_318, __v_319, __v_322]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[68].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i)?; } record.function_queries[68].output_at(__i).to_array::() }, _ => aiur_fn_68(__key, record, io_buffer, __cu)? } }; let __v_323: G = __r_arr[0]; - let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_323]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_323]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[67].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i)?; } record.function_queries[67].output_at(__i).to_array::() }, _ => aiur_fn_67(__key, record, io_buffer, __cu)? } }; let __v_324: G = __r_arr[0]; let __v_325: G = __r_arr[1]; let __v_326: G = __r_arr[2]; @@ -25597,37 +25841,37 @@ fn aiur_fn_242( let __v_353: G = __r_arr[29]; let __v_354: G = __r_arr[30]; let __v_355: G = __r_arr[31]; - let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_272]; let __cu = unconstrained; let __hit = record.function_queries[27].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i); } let __ret: [G; OUT_27] = unsafe { *(record.function_queries[27].output_at(__i).as_ptr() as *const [G; OUT_27]) }; __ret }, _ => aiur_fn_27(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_27] = { let __args: [G; IN_27] = [__v_272]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[27].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[27].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[27].bump_multiplicity(__i)?; } record.function_queries[27].output_at(__i).to_array::() }, _ => aiur_fn_27(__key, record, io_buffer, __cu)? } }; let __v_356: G = __r_arr[0]; let __v_357: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_357, __v_356]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_357, __v_356]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[204].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i)?; } record.function_queries[204].output_at(__i).to_array::() }, _ => aiur_fn_204(__key, record, io_buffer, __cu)? } }; let __v_358: G = __r_arr[0]; let __v_359: G = __r_arr[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_360: G = __r_arr[0]; let __v_361: G = G::from_bool((__v_360 == G::ZERO)); let __v_362: G = G::from_u64(0); if (__v_361 != __v_362) { return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_362.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_66]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_66]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_363: G = __r_arr[0]; if (__v_363 != __v_360) { return Err(ExecError::AssertEqMismatch { lhs: __v_363.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_68]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_68]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; if (__v_364 != __v_360) { return Err(ExecError::AssertEqMismatch { lhs: __v_364.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_61]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; if (__v_365 != __v_360) { return Err(ExecError::AssertEqMismatch { lhs: __v_365.as_canonical_u64(), rhs: __v_360.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[161].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i)?; } record.function_queries[161].output_at(__i).to_array::() }, _ => aiur_fn_161(__key, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; let __v_367: G = G::from_u64(1); if (__v_366 != __v_367) { @@ -25645,9 +25889,9 @@ fn aiur_fn_242( _ => { match __v_22.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_256, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_256, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[201].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i)?; } record.function_queries[201].output_at(__i).to_array::() }, _ => aiur_fn_201(__key, record, io_buffer, __cu)? } }; let __v_361: G = __r_arr[0]; - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_262, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_262, __v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[202].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i)?; } record.function_queries[202].output_at(__i).to_array::() }, _ => aiur_fn_202(__key, record, io_buffer, __cu)? } }; let __v_362: G = __r_arr[0]; match __v_24.as_canonical_u64() { _ => { @@ -25655,7 +25899,7 @@ fn aiur_fn_242( 0u64 => { let __v_363: G = G::from_u64(1); let __v_364: G = G::from_u64(1); - let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __v_364]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_365: G = { let __values: [G; 3] = [__v_363, __v_364, __v_364]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; break '__mc_2 [__v_365]; }, 1u64 => { @@ -25667,15 +25911,15 @@ fn aiur_fn_242( } }; let __v_363: G = __mc_out___mc_2[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_34, __v_272]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_34, __v_272]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_364: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_24, __v_364]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_24, __v_364]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_365: G = __r_arr[0]; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_363, __v_365]; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_363, __v_365]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[164].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i)?; } record.function_queries[164].output_at(__i).to_array::() }, _ => aiur_fn_164(__key, record, io_buffer, __cu)? } }; let __v_366: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_22, __v_366]; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_22, __v_366]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[165].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i)?; } record.function_queries[165].output_at(__i).to_array::() }, _ => aiur_fn_165(__key, record, io_buffer, __cu)? } }; let __v_367: G = __r_arr[0]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_266, __v_367]; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_266, __v_367]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[174].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i)?; } record.function_queries[174].output_at(__i).to_array::() }, _ => aiur_fn_174(__key, record, io_buffer, __cu)? } }; let __v_368: G = __r_arr[0]; let __v_369: G = G::from_u64(0); let __v_370: G = G::from_u64(109); @@ -25705,24 +25949,24 @@ fn aiur_fn_242( let __v_394: G = G::from_u64(118); let __v_395: G = G::from_u64(0); let __v_396: G = G::from_u64(48); - let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_398: G = { let __values: [G; 3] = [__v_393, __v_394, __v_397]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_399: G = { let __values: [G; 3] = [__v_391, __v_392, __v_398]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_400: G = { let __values: [G; 3] = [__v_389, __v_390, __v_399]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_401: G = { let __values: [G; 3] = [__v_387, __v_388, __v_400]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_402: G = { let __values: [G; 3] = [__v_385, __v_386, __v_401]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_403: G = { let __values: [G; 3] = [__v_383, __v_384, __v_402]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_404: G = { let __values: [G; 3] = [__v_381, __v_382, __v_403]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_405: G = { let __values: [G; 3] = [__v_379, __v_380, __v_404]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_406: G = { let __values: [G; 3] = [__v_377, __v_378, __v_405]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_407: G = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __v_408]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_397: G = { let __values: [G; 3] = [__v_395, __v_396, __v_368]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_398: G = { let __values: [G; 3] = [__v_393, __v_394, __v_397]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_399: G = { let __values: [G; 3] = [__v_391, __v_392, __v_398]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_400: G = { let __values: [G; 3] = [__v_389, __v_390, __v_399]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_401: G = { let __values: [G; 3] = [__v_387, __v_388, __v_400]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_402: G = { let __values: [G; 3] = [__v_385, __v_386, __v_401]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_403: G = { let __values: [G; 3] = [__v_383, __v_384, __v_402]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_404: G = { let __values: [G; 3] = [__v_381, __v_382, __v_403]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_405: G = { let __values: [G; 3] = [__v_379, __v_380, __v_404]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_406: G = { let __values: [G; 3] = [__v_377, __v_378, __v_405]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_407: G = { let __values: [G; 3] = [__v_375, __v_376, __v_406]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_408: G = { let __values: [G; 3] = [__v_373, __v_374, __v_407]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_409: G = { let __values: [G; 3] = [__v_371, __v_372, __v_408]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __v_410: G = { let __values: [G; 3] = [__v_369, __v_370, __v_409]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __v_411: G = G::from_u64(1); let __v_412: G = G::from_u64(1); - let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_410, __v_413]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_413: G = { let __values: [G; 3] = [__v_411, __v_412, __v_412]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_410, __v_413]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_414: G = __r_arr[0]; let __v_415: G = __r_arr[1]; let __v_416: G = __r_arr[2]; @@ -25743,17 +25987,17 @@ fn aiur_fn_242( let __v_431: G = __r_arr[17]; let __v_432: G = G::from_u64(1); let __v_433: G = G::from_u64(1); - let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_434: G = { let __values: [G; 3] = [__v_432, __v_433, __v_433]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_434]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_435: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_435]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_436: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_430, __v_436]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_430, __v_436]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_437: G = __r_arr[0]; let __v_438: G = G::from_u64(1); let __v_439: G = G::from_u64(1); - let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_437, __v_440]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_440: G = { let __values: [G; 3] = [__v_438, __v_439, __v_439]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_437, __v_440]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_441: G = __r_arr[0]; let __v_442: G = __r_arr[1]; let __v_443: G = __r_arr[2]; @@ -25774,26 +26018,26 @@ fn aiur_fn_242( let __v_458: G = __r_arr[17]; let __v_459: G = G::from_u64(1); let __v_460: G = G::from_u64(1); - let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __v_461: G = { let __values: [G; 3] = [__v_459, __v_460, __v_460]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_449, __v_450, __v_451, __v_452, __v_453, __v_454, __v_455, __v_456, __v_461]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_462: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_448, __v_462]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[162].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i)?; } record.function_queries[162].output_at(__i).to_array::() }, _ => aiur_fn_162(__key, record, io_buffer, __cu)? } }; let __v_463: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_457, __v_463]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_457, __v_463]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_464: G = __r_arr[0]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_464, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_464, __v_26]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_465: G = __r_arr[0]; let __v_466: G = G::from_u64(1); let __v_467: G = G::from_u64(1); - let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_30, __v_468]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_468: G = { let __values: [G; 3] = [__v_466, __v_467, __v_467]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_30, __v_468]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_469: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_465, __v_469]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_465, __v_469]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_470: G = __r_arr[0]; let __v_471: G = G::from_u64(1); let __v_472: G = G::from_u64(1); - let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_470, __v_473]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_473: G = { let __values: [G; 3] = [__v_471, __v_472, __v_472]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_470, __v_473]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_474: G = __r_arr[0]; let __v_475: G = __r_arr[1]; let __v_476: G = __r_arr[2]; @@ -25812,12 +26056,12 @@ fn aiur_fn_242( let __v_489: G = __r_arr[15]; let __v_490: G = __r_arr[16]; let __v_491: G = __r_arr[17]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_490, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_490, __v_28]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[172].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i)?; } record.function_queries[172].output_at(__i).to_array::() }, _ => aiur_fn_172(__key, record, io_buffer, __cu)? } }; let __v_492: G = __r_arr[0]; let __v_493: G = G::from_u64(1); let __v_494: G = G::from_u64(1); - let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_492, __v_495]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_495: G = { let __values: [G; 3] = [__v_493, __v_494, __v_494]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_492, __v_495]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_496: G = __r_arr[0]; let __v_497: G = __r_arr[1]; let __v_498: G = __r_arr[2]; @@ -26006,27 +26250,27 @@ fn aiur_fn_242( let __v_681: G = (__v_504 + __v_680); let __v_682: G = G::from_u64(0); let __v_683: G = G::from_u64(0); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_682, __v_683, __v_358, __v_534, __v_555, __v_576, __v_597]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[198].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i)?; } record.function_queries[198].output_at(__i).to_array::() }, _ => aiur_fn_198(__key, record, io_buffer, __cu)? } }; let __v_684: G = __r_arr[0]; let __v_685: G = __r_arr[1]; let __v_686: G = G::from_u64(0); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_361, __v_362, __v_34, __v_30, __v_66, __v_68, __v_63, __v_64, __v_61, __v_686, __v_684, __v_685, __v_534, __v_555, __v_576, __v_597, __v_618, __v_639, __v_660, __v_681]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[196].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i)?; } record.function_queries[196].output_at(__i).to_array::() }, _ => aiur_fn_196(__key, record, io_buffer, __cu)? } }; let __v_687: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_361]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_361]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_688: G = __r_arr[0]; match __v_38.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_689: G = __r_arr[0]; let __v_690: G = G::from_u64(1); let __v_691: G = G::from_u64(1); - let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_692: G = { let __values: [G; 3] = [__v_690, __v_691, __v_691]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_63.as_canonical_u64() { 0u64 => { break '__mc_3 [__v_692]; }, 1u64 => { - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_64, __v_692]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_64, __v_692]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_693: G = __r_arr[0]; break '__mc_3 [__v_693]; }, @@ -26036,18 +26280,18 @@ fn aiur_fn_242( } }; let __v_693: G = __mc_out___mc_3[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_61, __v_693]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_61, __v_693]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_694: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_68, __v_694]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_68, __v_694]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_695: G = __r_arr[0]; - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_66, __v_695]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_66, __v_695]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[126].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i)?; } record.function_queries[126].output_at(__i).to_array::() }, _ => aiur_fn_126(__key, record, io_buffer, __cu)? } }; let __v_696: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_512, __v_696]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_512, __v_696]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_697: G = __r_arr[0]; let __v_698: G = G::from_u64(1); let __v_699: G = G::from_u64(1); - let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_697, __v_700]; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __v_700: G = { let __values: [G; 3] = [__v_698, __v_699, __v_699]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_697, __v_700]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[168].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i)?; } record.function_queries[168].output_at(__i).to_array::() }, _ => aiur_fn_168(__key, record, io_buffer, __cu)? } }; let __v_701: G = __r_arr[0]; let __v_702: G = __r_arr[1]; let __v_703: G = __r_arr[2]; @@ -26108,28 +26352,28 @@ fn aiur_fn_242( let __v_758: G = (__v_743 + __v_757); let __v_759: G = (__v_741 + __v_758); let __v_760: G = (__v_709 + __v_759); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_717, __v_38, __v_40, __v_209]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_717, __v_38, __v_40, __v_209]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[130].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i)?; } record.function_queries[130].output_at(__i).to_array::() }, _ => aiur_fn_130(__key, record, io_buffer, __cu)? } }; let __v_761: G = __r_arr[0]; let __v_762: G = __r_arr[1]; let __v_763: G = G::from_u64(1); let __v_764: G = G::from_u64(1); - let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_50, __v_765]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_765: G = { let __values: [G; 3] = [__v_763, __v_764, __v_764]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_50, __v_765]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[124].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i)?; } record.function_queries[124].output_at(__i).to_array::() }, _ => aiur_fn_124(__key, record, io_buffer, __cu)? } }; let __v_766: G = __r_arr[0]; - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_762, __v_766]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_762, __v_766]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_767: G = __r_arr[0]; - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_767, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_767, __v_38]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[128].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i)?; } record.function_queries[128].output_at(__i).to_array::() }, _ => aiur_fn_128(__key, record, io_buffer, __cu)? } }; let __v_768: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_768, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_219]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[129].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i)?; } record.function_queries[129].output_at(__i).to_array::() }, _ => aiur_fn_129(__key, record, io_buffer, __cu)? } }; let __v_769: G = __r_arr[0]; let __v_770: G = __r_arr[1]; let __v_771: G = (__v_689 + __v_159); - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_769, __v_770, __v_199, __v_771]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_769, __v_770, __v_199, __v_771]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[151].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i)?; } record.function_queries[151].output_at(__i).to_array::() }, _ => aiur_fn_151(__key, record, io_buffer, __cu)? } }; let __v_772: G = __r_arr[0]; let __v_773: G = G::from_u64(0); - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_48, __v_773, __v_199]; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_44, __v_48, __v_773, __v_199]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[154].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i)?; } record.function_queries[154].output_at(__i).to_array::() }, _ => aiur_fn_154(__key, record, io_buffer, __cu)? } }; let __v_774: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_769, __v_770, __v_774, __v_739, __v_760, __v_66, __v_68, __v_61, __v_63, __v_64, __v_24, __v_26, __v_28, __v_363, __v_362, __v_34, __v_660, __v_681, __v_688, __v_159, __v_771, __v_761, __v_38, __v_50, __v_689]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[150].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i)?; } record.function_queries[150].output_at(__i).to_array::() }, _ => aiur_fn_150(__key, record, io_buffer, __cu)? } }; let __v_775: G = __r_arr[0]; let __v_776: G = G::from_u64(0); if (__v_169 != __v_776) { @@ -26143,15 +26387,15 @@ fn aiur_fn_242( if (__v_189 != __v_778) { return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_778.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[200].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i)?; } record.function_queries[200].output_at(__i).to_array::() }, _ => aiur_fn_200(__key, record, io_buffer, __cu)? } }; let __v_779: G = __r_arr[0]; let __v_780: G = G::from_u64(1); if (__v_779 != __v_780) { return Err(ExecError::AssertEqMismatch { lhs: __v_779.as_canonical_u64(), rhs: __v_780.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_22]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_781: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_256]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_256]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_782: G = __r_arr[0]; let __v_783: G = (__v_781 - __v_782); let __v_784: G = G::from_bool((__v_783 == G::ZERO)); @@ -26159,9 +26403,9 @@ fn aiur_fn_242( if (__v_784 != __v_785) { return Err(ExecError::AssertEqMismatch { lhs: __v_784.as_canonical_u64(), rhs: __v_785.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_361]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_361]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_786: G = __r_arr[0]; - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_30]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_787: G = __r_arr[0]; let __v_788: G = (__v_786 - __v_787); let __v_789: G = G::from_bool((__v_788 == G::ZERO)); @@ -26169,7 +26413,7 @@ fn aiur_fn_242( if (__v_789 != __v_790) { return Err(ExecError::AssertEqMismatch { lhs: __v_789.as_canonical_u64(), rhs: __v_790.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_40]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_791: G = __r_arr[0]; let __v_792: G = (__v_791 - __v_689); let __v_793: G = G::from_bool((__v_792 == G::ZERO)); @@ -26177,16 +26421,16 @@ fn aiur_fn_242( if (__v_793 != __v_794) { return Err(ExecError::AssertEqMismatch { lhs: __v_793.as_canonical_u64(), rhs: __v_794.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_44]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_795: G = __r_arr[0]; let __v_796: G = G::from_u64(3); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_63, __v_64]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[135].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i)?; } record.function_queries[135].output_at(__i).to_array::() }, _ => aiur_fn_135(__key, record, io_buffer, __cu)? } }; let __v_797: G = __r_arr[0]; let __v_798: G = (__v_796 + __v_797); if (__v_795 != __v_798) { return Err(ExecError::AssertEqMismatch { lhs: __v_795.as_canonical_u64(), rhs: __v_798.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_48]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_799: G = __r_arr[0]; let __v_800: G = (__v_799 - __v_689); let __v_801: G = G::from_bool((__v_800 == G::ZERO)); @@ -26194,26 +26438,26 @@ fn aiur_fn_242( if (__v_801 != __v_802) { return Err(ExecError::AssertEqMismatch { lhs: __v_801.as_canonical_u64(), rhs: __v_802.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_50]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_50]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_803: G = __r_arr[0]; let __v_804: G = G::from_u64(1); if (__v_803 != __v_804) { return Err(ExecError::AssertEqMismatch { lhs: __v_803.as_canonical_u64(), rhs: __v_804.as_canonical_u64(), msg: None }); } let __v_805: G = G::from_u64(33); - let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_806: G = { let __a_val = __v_771.as_canonical_u64(); let __b_val = __v_805.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]))?; record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]))?; } __result }; let __v_807: G = G::from_u64(1); if (__v_806 != __v_807) { return Err(ExecError::AssertEqMismatch { lhs: __v_806.as_canonical_u64(), rhs: __v_807.as_canonical_u64(), msg: None }); } - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_44, __v_772, __v_24, __v_26, __v_28, __v_363, __v_63, __v_64, __v_362, __v_34, __v_688, __v_159, __v_771]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[155].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i)?; } record.function_queries[155].output_at(__i).to_array::() }, _ => aiur_fn_155(__key, record, io_buffer, __cu)? } }; let __v_808: G = __r_arr[0]; let __v_809: G = G::from_u64(1); if (__v_808 != __v_809) { return Err(ExecError::AssertEqMismatch { lhs: __v_808.as_canonical_u64(), rhs: __v_809.as_canonical_u64(), msg: None }); } let __v_810: G = G::from_u64(0); - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_48, __v_38, __v_775, __v_772, __v_810, __v_771]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[158].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i)?; } record.function_queries[158].output_at(__i).to_array::() }, _ => aiur_fn_158(__key, record, io_buffer, __cu)? } }; let __v_811: G = __r_arr[0]; break '__mc_1 [__v_811]; }, @@ -26328,7 +26572,7 @@ fn aiur_fn_242( if (__v_434 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_434.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_263.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_435: G = __loaded[0]; let __v_436: G = __loaded[1]; let __v_437: G = __loaded[2]; @@ -26439,7 +26683,7 @@ fn aiur_fn_242( if (__v_511 != __v_15) { return Err(ExecError::AssertEqMismatch { lhs: __v_511.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: None }); } - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_359.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_512: G = __loaded[0]; let __v_513: G = __loaded[1]; let __v_514: G = __loaded[2]; @@ -26463,7 +26707,7 @@ fn aiur_fn_242( return Err(ExecError::AssertEqMismatch { lhs: __v_361.as_canonical_u64(), rhs: __v_518.as_canonical_u64(), msg: None }); } let __ret: [G; OUT_242] = []; - record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[242].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }) } @@ -26472,24 +26716,25 @@ const INPUT_SIZE_243: usize = 2; const IN_243: usize = 2; const OUT_243: usize = 1; fn aiur_fn_243( - inp: [G; IN_243], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_243], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + record.checkpoint(243); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_243] = [__v_4]; - record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[243].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26503,14 +26748,15 @@ const INPUT_SIZE_244: usize = 1; const IN_244: usize = 1; const OUT_244: usize = 1; fn aiur_fn_244( - inp: [G; IN_244], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_244], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(244); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26518,16 +26764,16 @@ fn aiur_fn_244( 1u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_244] = [__v_4]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[244].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[244].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i)?; } record.function_queries[244].output_at(__i).to_array::() }, _ => aiur_fn_244(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); let __ret: [G; OUT_244] = [__v_6]; - record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[244].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26541,14 +26787,15 @@ const INPUT_SIZE_245: usize = 1; const IN_245: usize = 1; const OUT_245: usize = 1; fn aiur_fn_245( - inp: [G; IN_245], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_245], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + record.checkpoint(245); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26557,16 +26804,16 @@ fn aiur_fn_245( 1u64 => { let __v_5: G = G::from_u64(0); let __ret: [G; OUT_245] = [__v_5]; - record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_4]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[245].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i)?; } record.function_queries[245].output_at(__i).to_array::() }, _ => aiur_fn_245(__key, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_5 + __v_6); let __ret: [G; OUT_245] = [__v_7]; - record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[245].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26580,31 +26827,32 @@ const INPUT_SIZE_246: usize = 2; const IN_246: usize = 2; const OUT_246: usize = 1; fn aiur_fn_246( - inp: [G; IN_246], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_246], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(246); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_246] = [__v_1]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[246].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i)?; } record.function_queries[246].output_at(__i).to_array::() }, _ => aiur_fn_246(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_246] = [__v_7]; - record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[246].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26618,14 +26866,15 @@ const INPUT_SIZE_247: usize = 1; const IN_247: usize = 1; const OUT_247: usize = 1; fn aiur_fn_247( - inp: [G; IN_247], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_247], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + record.checkpoint(247); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26636,16 +26885,16 @@ fn aiur_fn_247( 1u64 => { let __v_7: G = G::from_u64(0); let __ret: [G; OUT_247] = [__v_7]; - record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[247].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_6]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[247].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i)?; } record.function_queries[247].output_at(__i).to_array::() }, _ => aiur_fn_247(__key, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); let __ret: [G; OUT_247] = [__v_9]; - record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[247].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26659,14 +26908,15 @@ const INPUT_SIZE_248: usize = 1; const IN_248: usize = 1; const OUT_248: usize = 1; fn aiur_fn_248( - inp: [G; IN_248], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_248], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + record.checkpoint(248); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<7>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26678,16 +26928,16 @@ fn aiur_fn_248( 1u64 => { let __v_8: G = G::from_u64(0); let __ret: [G; OUT_248] = [__v_8]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[248].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i)?; } record.function_queries[248].output_at(__i).to_array::() }, _ => aiur_fn_248(__key, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 + __v_9); let __ret: [G; OUT_248] = [__v_10]; - record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[248].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26701,14 +26951,15 @@ const INPUT_SIZE_249: usize = 1; const IN_249: usize = 1; const OUT_249: usize = 1; fn aiur_fn_249( - inp: [G; IN_249], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_249], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(249); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26723,16 +26974,16 @@ fn aiur_fn_249( 1u64 => { let __v_11: G = G::from_u64(0); let __ret: [G; OUT_249] = [__v_11]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[249].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_10]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[249].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i)?; } record.function_queries[249].output_at(__i).to_array::() }, _ => aiur_fn_249(__key, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); let __ret: [G; OUT_249] = [__v_13]; - record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[249].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26746,17 +26997,18 @@ const INPUT_SIZE_250: usize = 2; const IN_250: usize = 2; const OUT_250: usize = 4; fn aiur_fn_250( - inp: [G; IN_250], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_250], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } }; + record.checkpoint(250); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[259].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i)?; } record.function_queries[259].output_at(__i).to_array::() }, _ => aiur_fn_259(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -26766,7 +27018,7 @@ fn aiur_fn_250( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_250] = [__v_4, __v_5, __v_6, __v_7]; - record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[250].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26780,14 +27032,15 @@ const INPUT_SIZE_251: usize = 1; const IN_251: usize = 1; const OUT_251: usize = 1; fn aiur_fn_251( - inp: [G; IN_251], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_251], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + record.checkpoint(251); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26795,13 +27048,13 @@ fn aiur_fn_251( 1u64 => { let __v_4: G = G::from_u64(1); let __ret: [G; OUT_251] = [__v_4]; - record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[251].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); let __ret: [G; OUT_251] = [__v_4]; - record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[251].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26815,17 +27068,18 @@ const INPUT_SIZE_252: usize = 2; const IN_252: usize = 2; const OUT_252: usize = 2; fn aiur_fn_252( - inp: [G; IN_252], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_252], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } }; + record.checkpoint(252); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[258].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i)?; } record.function_queries[258].output_at(__i).to_array::() }, _ => aiur_fn_258(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -26833,7 +27087,7 @@ fn aiur_fn_252( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_252] = [__v_4, __v_5]; - record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[252].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26847,15 +27101,16 @@ const INPUT_SIZE_253: usize = 2; const IN_253: usize = 2; const OUT_253: usize = 1; fn aiur_fn_253( - inp: [G; IN_253], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_253], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + record.checkpoint(253); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -26869,16 +27124,16 @@ fn aiur_fn_253( match __v_2.as_canonical_u64() { 1u64 => { let __ret: [G; OUT_253] = [__v_1]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[253].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_11, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[253].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i)?; } record.function_queries[253].output_at(__i).to_array::() }, _ => aiur_fn_253(__key, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __key = QueryKey::new(__values); let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_prehashed(&__key) { if !unconstrained { __mq.bump_multiplicity(__i)?; } __mq.output_at(__i).at(0) } else { let __ptr = G::from_usize(__mq.len()); __mq.insert_prehashed(&__key, &[__ptr], G::from_bool(!unconstrained))?; __ptr } }; let __ret: [G; OUT_253] = [__v_14]; - record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[253].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26892,14 +27147,15 @@ const INPUT_SIZE_254: usize = 1; const IN_254: usize = 1; const OUT_254: usize = 1; fn aiur_fn_254( - inp: [G; IN_254], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_254], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + record.checkpoint(254); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<5>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26909,16 +27165,16 @@ fn aiur_fn_254( 1u64 => { let __v_6: G = G::from_u64(0); let __ret: [G; OUT_254] = [__v_6]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_5]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[254].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i)?; } record.function_queries[254].output_at(__i).to_array::() }, _ => aiur_fn_254(__key, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); let __ret: [G; OUT_254] = [__v_8]; - record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[254].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26932,33 +27188,34 @@ const INPUT_SIZE_255: usize = 2; const IN_255: usize = 2; const OUT_255: usize = 1; fn aiur_fn_255( - inp: [G; IN_255], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(255); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_0]; - record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[255].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i)?; } record.function_queries[255].output_at(__i).to_array::() }, _ => aiur_fn_255(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<3>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_255] = [__v_7]; - record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[255].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -26974,14 +27231,15 @@ const INPUT_SIZE_256: usize = 1; const IN_256: usize = 1; const OUT_256: usize = 1; fn aiur_fn_256( - inp: [G; IN_256], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_256], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + record.checkpoint(256); + let __v_0: G = inp.values()[0]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<8>() }; let __v_1: G = __loaded[0]; let __v_2: G = __loaded[1]; let __v_3: G = __loaded[2]; @@ -26994,16 +27252,16 @@ fn aiur_fn_256( 1u64 => { let __v_9: G = G::from_u64(0); let __ret: [G; OUT_256] = [__v_9]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_8]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[256].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i)?; } record.function_queries[256].output_at(__i).to_array::() }, _ => aiur_fn_256(__key, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_9 + __v_10); let __ret: [G; OUT_256] = [__v_11]; - record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[256].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27017,17 +27275,18 @@ const INPUT_SIZE_257: usize = 2; const IN_257: usize = 2; const OUT_257: usize = 8; fn aiur_fn_257( - inp: [G; IN_257], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; + record.checkpoint(257); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[260].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i)?; } record.function_queries[260].output_at(__i).to_array::() }, _ => aiur_fn_260(__key, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_3: G = __loaded[0]; let __v_4: G = __loaded[1]; let __v_5: G = __loaded[2]; @@ -27041,7 +27300,7 @@ fn aiur_fn_257( match __v_3.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_257] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[257].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27055,26 +27314,27 @@ const INPUT_SIZE_258: usize = 2; const IN_258: usize = 2; const OUT_258: usize = 1; fn aiur_fn_258( - inp: [G; IN_258], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(258); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_258] = [__v_0]; - record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[258].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i)?; } record.function_queries[258].output_at(__i).to_array::() }, _ => aiur_fn_258(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<4>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -27082,7 +27342,7 @@ fn aiur_fn_258( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_258] = [__v_8]; - record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[258].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27098,26 +27358,27 @@ const INPUT_SIZE_259: usize = 2; const IN_259: usize = 2; const OUT_259: usize = 1; fn aiur_fn_259( - inp: [G; IN_259], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(259); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_259] = [__v_0]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[259].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i)?; } record.function_queries[259].output_at(__i).to_array::() }, _ => aiur_fn_259(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<6>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -27127,7 +27388,7 @@ fn aiur_fn_259( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_259] = [__v_10]; - record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[259].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27143,26 +27404,27 @@ const INPUT_SIZE_260: usize = 2; const IN_260: usize = 2; const OUT_260: usize = 1; fn aiur_fn_260( - inp: [G; IN_260], + inp: QueryKey, record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = inp[0]; - let __v_1: G = inp[1]; + record.checkpoint(260); + let __v_0: G = inp.values()[0]; + let __v_1: G = inp.values()[1]; match __v_1.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_260] = [__v_0]; - record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[260].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_3]; let __key = QueryKey::new(__args); let __cu = unconstrained; let __hit = record.function_queries[260].get_prehashed(&__key); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i)?; } record.function_queries[260].output_at(__i).to_array::() }, _ => aiur_fn_260(__key, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize)?; } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); __args.to_array::<10>() }; let __v_5: G = __loaded[0]; let __v_6: G = __loaded[1]; let __v_7: G = __loaded[2]; @@ -27176,7 +27438,7 @@ fn aiur_fn_260( match __v_5.as_canonical_u64() { 0u64 => { let __ret: [G; OUT_260] = [__v_14]; - record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained); + record.function_queries[260].finish_prehashed(&inp, &__ret[..], !unconstrained)?; return Ok(__ret); }, _ => { @@ -27197,1307 +27459,1307 @@ pub(crate) fn execute_generated( match fun_idx as u64 { 0u64 => { let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_0(__inp, record, io_buffer, false)?; + let __out = aiur_fn_0(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 1u64 => { let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_1(__inp, record, io_buffer, false)?; + let __out = aiur_fn_1(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 2u64 => { let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_2(__inp, record, io_buffer, false)?; + let __out = aiur_fn_2(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 3u64 => { let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_3(__inp, record, io_buffer, false)?; + let __out = aiur_fn_3(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 4u64 => { let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_4(__inp, record, io_buffer, false)?; + let __out = aiur_fn_4(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 5u64 => { let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_5(__inp, record, io_buffer, false)?; + let __out = aiur_fn_5(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 6u64 => { let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_6(__inp, record, io_buffer, false)?; + let __out = aiur_fn_6(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 7u64 => { let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_7(__inp, record, io_buffer, false)?; + let __out = aiur_fn_7(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 8u64 => { let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_8(__inp, record, io_buffer, false)?; + let __out = aiur_fn_8(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 9u64 => { let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_9(__inp, record, io_buffer, false)?; + let __out = aiur_fn_9(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 10u64 => { let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_10(__inp, record, io_buffer, false)?; + let __out = aiur_fn_10(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 11u64 => { let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_11(__inp, record, io_buffer, false)?; + let __out = aiur_fn_11(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 12u64 => { let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_12(__inp, record, io_buffer, false)?; + let __out = aiur_fn_12(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 13u64 => { let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_13(__inp, record, io_buffer, false)?; + let __out = aiur_fn_13(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 14u64 => { let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_14(__inp, record, io_buffer, false)?; + let __out = aiur_fn_14(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 15u64 => { let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_15(__inp, record, io_buffer, false)?; + let __out = aiur_fn_15(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 16u64 => { let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_16(__inp, record, io_buffer, false)?; + let __out = aiur_fn_16(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 17u64 => { let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_17(__inp, record, io_buffer, false)?; + let __out = aiur_fn_17(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 18u64 => { let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_18(__inp, record, io_buffer, false)?; + let __out = aiur_fn_18(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 19u64 => { let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_19(__inp, record, io_buffer, false)?; + let __out = aiur_fn_19(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 20u64 => { let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_20(__inp, record, io_buffer, false)?; + let __out = aiur_fn_20(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 21u64 => { let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_21(__inp, record, io_buffer, false)?; + let __out = aiur_fn_21(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 22u64 => { let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_22(__inp, record, io_buffer, false)?; + let __out = aiur_fn_22(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 23u64 => { let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_23(__inp, record, io_buffer, false)?; + let __out = aiur_fn_23(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 24u64 => { let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_24(__inp, record, io_buffer, false)?; + let __out = aiur_fn_24(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 25u64 => { let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_25(__inp, record, io_buffer, false)?; + let __out = aiur_fn_25(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 26u64 => { let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_26(__inp, record, io_buffer, false)?; + let __out = aiur_fn_26(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 27u64 => { let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_27(__inp, record, io_buffer, false)?; + let __out = aiur_fn_27(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 28u64 => { let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_28(__inp, record, io_buffer, false)?; + let __out = aiur_fn_28(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 29u64 => { let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_29(__inp, record, io_buffer, false)?; + let __out = aiur_fn_29(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 30u64 => { let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_30(__inp, record, io_buffer, false)?; + let __out = aiur_fn_30(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 31u64 => { let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_31(__inp, record, io_buffer, false)?; + let __out = aiur_fn_31(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 32u64 => { let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_32(__inp, record, io_buffer, false)?; + let __out = aiur_fn_32(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 33u64 => { let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_33(__inp, record, io_buffer, false)?; + let __out = aiur_fn_33(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 34u64 => { let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_34(__inp, record, io_buffer, false)?; + let __out = aiur_fn_34(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 35u64 => { let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_35(__inp, record, io_buffer, false)?; + let __out = aiur_fn_35(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 36u64 => { let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_36(__inp, record, io_buffer, false)?; + let __out = aiur_fn_36(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 37u64 => { let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_37(__inp, record, io_buffer, false)?; + let __out = aiur_fn_37(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 38u64 => { let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_38(__inp, record, io_buffer, false)?; + let __out = aiur_fn_38(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 39u64 => { let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_39(__inp, record, io_buffer, false)?; + let __out = aiur_fn_39(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 40u64 => { let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_40(__inp, record, io_buffer, false)?; + let __out = aiur_fn_40(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 41u64 => { let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_41(__inp, record, io_buffer, false)?; + let __out = aiur_fn_41(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 42u64 => { let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_42(__inp, record, io_buffer, false)?; + let __out = aiur_fn_42(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 43u64 => { let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_43(__inp, record, io_buffer, false)?; + let __out = aiur_fn_43(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 44u64 => { let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_44(__inp, record, io_buffer, false)?; + let __out = aiur_fn_44(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 45u64 => { let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_45(__inp, record, io_buffer, false)?; + let __out = aiur_fn_45(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 46u64 => { let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_46(__inp, record, io_buffer, false)?; + let __out = aiur_fn_46(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 47u64 => { let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_47(__inp, record, io_buffer, false)?; + let __out = aiur_fn_47(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 48u64 => { let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_48(__inp, record, io_buffer, false)?; + let __out = aiur_fn_48(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 49u64 => { let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_49(__inp, record, io_buffer, false)?; + let __out = aiur_fn_49(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 50u64 => { let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_50(__inp, record, io_buffer, false)?; + let __out = aiur_fn_50(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 51u64 => { let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_51(__inp, record, io_buffer, false)?; + let __out = aiur_fn_51(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 52u64 => { let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_52(__inp, record, io_buffer, false)?; + let __out = aiur_fn_52(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 53u64 => { let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_53(__inp, record, io_buffer, false)?; + let __out = aiur_fn_53(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 54u64 => { let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_54(__inp, record, io_buffer, false)?; + let __out = aiur_fn_54(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 55u64 => { let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_55(__inp, record, io_buffer, false)?; + let __out = aiur_fn_55(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 56u64 => { let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_56(__inp, record, io_buffer, false)?; + let __out = aiur_fn_56(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 57u64 => { let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_57(__inp, record, io_buffer, false)?; + let __out = aiur_fn_57(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 58u64 => { let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_58(__inp, record, io_buffer, false)?; + let __out = aiur_fn_58(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 59u64 => { let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_59(__inp, record, io_buffer, false)?; + let __out = aiur_fn_59(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 60u64 => { let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_60(__inp, record, io_buffer, false)?; + let __out = aiur_fn_60(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 61u64 => { let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_61(__inp, record, io_buffer, false)?; + let __out = aiur_fn_61(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 62u64 => { let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_62(__inp, record, io_buffer, false)?; + let __out = aiur_fn_62(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 63u64 => { let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_63(__inp, record, io_buffer, false)?; + let __out = aiur_fn_63(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 64u64 => { let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_64(__inp, record, io_buffer, false)?; + let __out = aiur_fn_64(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 65u64 => { let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_65(__inp, record, io_buffer, false)?; + let __out = aiur_fn_65(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 66u64 => { let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_66(__inp, record, io_buffer, false)?; + let __out = aiur_fn_66(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 67u64 => { let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_67(__inp, record, io_buffer, false)?; + let __out = aiur_fn_67(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 68u64 => { let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_68(__inp, record, io_buffer, false)?; + let __out = aiur_fn_68(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 69u64 => { let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_69(__inp, record, io_buffer, false)?; + let __out = aiur_fn_69(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 70u64 => { let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_70(__inp, record, io_buffer, false)?; + let __out = aiur_fn_70(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 71u64 => { let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_71(__inp, record, io_buffer, false)?; + let __out = aiur_fn_71(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 72u64 => { let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_72(__inp, record, io_buffer, false)?; + let __out = aiur_fn_72(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 73u64 => { let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_73(__inp, record, io_buffer, false)?; + let __out = aiur_fn_73(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 74u64 => { let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_74(__inp, record, io_buffer, false)?; + let __out = aiur_fn_74(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 75u64 => { let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_75(__inp, record, io_buffer, false)?; + let __out = aiur_fn_75(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 76u64 => { let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_76(__inp, record, io_buffer, false)?; + let __out = aiur_fn_76(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 77u64 => { let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_77(__inp, record, io_buffer, false)?; + let __out = aiur_fn_77(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 78u64 => { let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_78(__inp, record, io_buffer, false)?; + let __out = aiur_fn_78(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 79u64 => { let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_79(__inp, record, io_buffer, false)?; + let __out = aiur_fn_79(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 80u64 => { let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_80(__inp, record, io_buffer, false)?; + let __out = aiur_fn_80(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 81u64 => { let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_81(__inp, record, io_buffer, false)?; + let __out = aiur_fn_81(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 82u64 => { let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_82(__inp, record, io_buffer, false)?; + let __out = aiur_fn_82(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 83u64 => { let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_83(__inp, record, io_buffer, false)?; + let __out = aiur_fn_83(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 84u64 => { let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_84(__inp, record, io_buffer, false)?; + let __out = aiur_fn_84(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 85u64 => { let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_85(__inp, record, io_buffer, false)?; + let __out = aiur_fn_85(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 86u64 => { let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_86(__inp, record, io_buffer, false)?; + let __out = aiur_fn_86(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 87u64 => { let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_87(__inp, record, io_buffer, false)?; + let __out = aiur_fn_87(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 88u64 => { let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_88(__inp, record, io_buffer, false)?; + let __out = aiur_fn_88(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 89u64 => { let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_89(__inp, record, io_buffer, false)?; + let __out = aiur_fn_89(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 90u64 => { let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_90(__inp, record, io_buffer, false)?; + let __out = aiur_fn_90(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 91u64 => { let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_91(__inp, record, io_buffer, false)?; + let __out = aiur_fn_91(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 92u64 => { let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_92(__inp, record, io_buffer, false)?; + let __out = aiur_fn_92(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 93u64 => { let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_93(__inp, record, io_buffer, false)?; + let __out = aiur_fn_93(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 94u64 => { let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_94(__inp, record, io_buffer, false)?; + let __out = aiur_fn_94(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 95u64 => { let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_95(__inp, record, io_buffer, false)?; + let __out = aiur_fn_95(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 96u64 => { let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_96(__inp, record, io_buffer, false)?; + let __out = aiur_fn_96(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 97u64 => { let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_97(__inp, record, io_buffer, false)?; + let __out = aiur_fn_97(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 98u64 => { let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_98(__inp, record, io_buffer, false)?; + let __out = aiur_fn_98(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 99u64 => { let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_99(__inp, record, io_buffer, false)?; + let __out = aiur_fn_99(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 100u64 => { let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_100(__inp, record, io_buffer, false)?; + let __out = aiur_fn_100(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 101u64 => { let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_101(__inp, record, io_buffer, false)?; + let __out = aiur_fn_101(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 102u64 => { let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_102(__inp, record, io_buffer, false)?; + let __out = aiur_fn_102(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 103u64 => { let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_103(__inp, record, io_buffer, false)?; + let __out = aiur_fn_103(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 104u64 => { let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_104(__inp, record, io_buffer, false)?; + let __out = aiur_fn_104(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 105u64 => { let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_105(__inp, record, io_buffer, false)?; + let __out = aiur_fn_105(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 106u64 => { let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_106(__inp, record, io_buffer, false)?; + let __out = aiur_fn_106(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 107u64 => { let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_107(__inp, record, io_buffer, false)?; + let __out = aiur_fn_107(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 108u64 => { let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_108(__inp, record, io_buffer, false)?; + let __out = aiur_fn_108(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 109u64 => { let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_109(__inp, record, io_buffer, false)?; + let __out = aiur_fn_109(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 110u64 => { let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_110(__inp, record, io_buffer, false)?; + let __out = aiur_fn_110(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 111u64 => { let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_111(__inp, record, io_buffer, false)?; + let __out = aiur_fn_111(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 112u64 => { let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_112(__inp, record, io_buffer, false)?; + let __out = aiur_fn_112(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 113u64 => { let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_113(__inp, record, io_buffer, false)?; + let __out = aiur_fn_113(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 114u64 => { let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_114(__inp, record, io_buffer, false)?; + let __out = aiur_fn_114(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 115u64 => { let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_115(__inp, record, io_buffer, false)?; + let __out = aiur_fn_115(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 116u64 => { let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_116(__inp, record, io_buffer, false)?; + let __out = aiur_fn_116(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 117u64 => { let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_117(__inp, record, io_buffer, false)?; + let __out = aiur_fn_117(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 118u64 => { let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_118(__inp, record, io_buffer, false)?; + let __out = aiur_fn_118(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 119u64 => { let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_119(__inp, record, io_buffer, false)?; + let __out = aiur_fn_119(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 120u64 => { let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_120(__inp, record, io_buffer, false)?; + let __out = aiur_fn_120(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 121u64 => { let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_121(__inp, record, io_buffer, false)?; + let __out = aiur_fn_121(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 122u64 => { let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_122(__inp, record, io_buffer, false)?; + let __out = aiur_fn_122(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 123u64 => { let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_123(__inp, record, io_buffer, false)?; + let __out = aiur_fn_123(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 124u64 => { let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_124(__inp, record, io_buffer, false)?; + let __out = aiur_fn_124(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 125u64 => { let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_125(__inp, record, io_buffer, false)?; + let __out = aiur_fn_125(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 126u64 => { let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_126(__inp, record, io_buffer, false)?; + let __out = aiur_fn_126(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 127u64 => { let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_127(__inp, record, io_buffer, false)?; + let __out = aiur_fn_127(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 128u64 => { let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_128(__inp, record, io_buffer, false)?; + let __out = aiur_fn_128(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 129u64 => { let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_129(__inp, record, io_buffer, false)?; + let __out = aiur_fn_129(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 130u64 => { let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_130(__inp, record, io_buffer, false)?; + let __out = aiur_fn_130(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 131u64 => { let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_131(__inp, record, io_buffer, false)?; + let __out = aiur_fn_131(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 132u64 => { let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_132(__inp, record, io_buffer, false)?; + let __out = aiur_fn_132(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 133u64 => { let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_133(__inp, record, io_buffer, false)?; + let __out = aiur_fn_133(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 134u64 => { let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_134(__inp, record, io_buffer, false)?; + let __out = aiur_fn_134(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 135u64 => { let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_135(__inp, record, io_buffer, false)?; + let __out = aiur_fn_135(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 136u64 => { let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_136(__inp, record, io_buffer, false)?; + let __out = aiur_fn_136(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 137u64 => { let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_137(__inp, record, io_buffer, false)?; + let __out = aiur_fn_137(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 138u64 => { let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_138(__inp, record, io_buffer, false)?; + let __out = aiur_fn_138(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 139u64 => { let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_139(__inp, record, io_buffer, false)?; + let __out = aiur_fn_139(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 140u64 => { let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_140(__inp, record, io_buffer, false)?; + let __out = aiur_fn_140(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 141u64 => { let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_141(__inp, record, io_buffer, false)?; + let __out = aiur_fn_141(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 142u64 => { let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_142(__inp, record, io_buffer, false)?; + let __out = aiur_fn_142(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 143u64 => { let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_143(__inp, record, io_buffer, false)?; + let __out = aiur_fn_143(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 144u64 => { let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_144(__inp, record, io_buffer, false)?; + let __out = aiur_fn_144(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 145u64 => { let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_145(__inp, record, io_buffer, false)?; + let __out = aiur_fn_145(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 146u64 => { let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_146(__inp, record, io_buffer, false)?; + let __out = aiur_fn_146(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 147u64 => { let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_147(__inp, record, io_buffer, false)?; + let __out = aiur_fn_147(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 148u64 => { let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_148(__inp, record, io_buffer, false)?; + let __out = aiur_fn_148(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 149u64 => { let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_149(__inp, record, io_buffer, false)?; + let __out = aiur_fn_149(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 150u64 => { let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_150(__inp, record, io_buffer, false)?; + let __out = aiur_fn_150(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 151u64 => { let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_151(__inp, record, io_buffer, false)?; + let __out = aiur_fn_151(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 152u64 => { let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_152(__inp, record, io_buffer, false)?; + let __out = aiur_fn_152(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 153u64 => { let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_153(__inp, record, io_buffer, false)?; + let __out = aiur_fn_153(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 154u64 => { let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_154(__inp, record, io_buffer, false)?; + let __out = aiur_fn_154(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 155u64 => { let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_155(__inp, record, io_buffer, false)?; + let __out = aiur_fn_155(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 156u64 => { let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_156(__inp, record, io_buffer, false)?; + let __out = aiur_fn_156(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 157u64 => { let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_157(__inp, record, io_buffer, false)?; + let __out = aiur_fn_157(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 158u64 => { let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_158(__inp, record, io_buffer, false)?; + let __out = aiur_fn_158(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 159u64 => { let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_159(__inp, record, io_buffer, false)?; + let __out = aiur_fn_159(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 160u64 => { let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_160(__inp, record, io_buffer, false)?; + let __out = aiur_fn_160(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 161u64 => { let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_161(__inp, record, io_buffer, false)?; + let __out = aiur_fn_161(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 162u64 => { let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_162(__inp, record, io_buffer, false)?; + let __out = aiur_fn_162(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 163u64 => { let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_163(__inp, record, io_buffer, false)?; + let __out = aiur_fn_163(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 164u64 => { let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_164(__inp, record, io_buffer, false)?; + let __out = aiur_fn_164(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 165u64 => { let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_165(__inp, record, io_buffer, false)?; + let __out = aiur_fn_165(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 166u64 => { let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_166(__inp, record, io_buffer, false)?; + let __out = aiur_fn_166(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 167u64 => { let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_167(__inp, record, io_buffer, false)?; + let __out = aiur_fn_167(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 168u64 => { let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_168(__inp, record, io_buffer, false)?; + let __out = aiur_fn_168(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 169u64 => { let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_169(__inp, record, io_buffer, false)?; + let __out = aiur_fn_169(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 170u64 => { let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_170(__inp, record, io_buffer, false)?; + let __out = aiur_fn_170(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 171u64 => { let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_171(__inp, record, io_buffer, false)?; + let __out = aiur_fn_171(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 172u64 => { let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_172(__inp, record, io_buffer, false)?; + let __out = aiur_fn_172(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 173u64 => { let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_173(__inp, record, io_buffer, false)?; + let __out = aiur_fn_173(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 174u64 => { let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_174(__inp, record, io_buffer, false)?; + let __out = aiur_fn_174(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 175u64 => { let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_175(__inp, record, io_buffer, false)?; + let __out = aiur_fn_175(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 176u64 => { let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_176(__inp, record, io_buffer, false)?; + let __out = aiur_fn_176(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 177u64 => { let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_177(__inp, record, io_buffer, false)?; + let __out = aiur_fn_177(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 178u64 => { let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_178(__inp, record, io_buffer, false)?; + let __out = aiur_fn_178(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 179u64 => { let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_179(__inp, record, io_buffer, false)?; + let __out = aiur_fn_179(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 180u64 => { let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_180(__inp, record, io_buffer, false)?; + let __out = aiur_fn_180(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 181u64 => { let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_181(__inp, record, io_buffer, false)?; + let __out = aiur_fn_181(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 182u64 => { let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_182(__inp, record, io_buffer, false)?; + let __out = aiur_fn_182(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 183u64 => { let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_183(__inp, record, io_buffer, false)?; + let __out = aiur_fn_183(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 184u64 => { let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_184(__inp, record, io_buffer, false)?; + let __out = aiur_fn_184(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 185u64 => { let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_185(__inp, record, io_buffer, false)?; + let __out = aiur_fn_185(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 186u64 => { let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_186(__inp, record, io_buffer, false)?; + let __out = aiur_fn_186(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 187u64 => { let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_187(__inp, record, io_buffer, false)?; + let __out = aiur_fn_187(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 188u64 => { let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_188(__inp, record, io_buffer, false)?; + let __out = aiur_fn_188(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 189u64 => { let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_189(__inp, record, io_buffer, false)?; + let __out = aiur_fn_189(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 190u64 => { let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_190(__inp, record, io_buffer, false)?; + let __out = aiur_fn_190(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 191u64 => { let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_191(__inp, record, io_buffer, false)?; + let __out = aiur_fn_191(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 192u64 => { let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_192(__inp, record, io_buffer, false)?; + let __out = aiur_fn_192(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 193u64 => { let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_193(__inp, record, io_buffer, false)?; + let __out = aiur_fn_193(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 194u64 => { let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_194(__inp, record, io_buffer, false)?; + let __out = aiur_fn_194(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 195u64 => { let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_195(__inp, record, io_buffer, false)?; + let __out = aiur_fn_195(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 196u64 => { let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_196(__inp, record, io_buffer, false)?; + let __out = aiur_fn_196(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 197u64 => { let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_197(__inp, record, io_buffer, false)?; + let __out = aiur_fn_197(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 198u64 => { let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_198(__inp, record, io_buffer, false)?; + let __out = aiur_fn_198(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 199u64 => { let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_199(__inp, record, io_buffer, false)?; + let __out = aiur_fn_199(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 200u64 => { let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_200(__inp, record, io_buffer, false)?; + let __out = aiur_fn_200(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 201u64 => { let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_201(__inp, record, io_buffer, false)?; + let __out = aiur_fn_201(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 202u64 => { let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_202(__inp, record, io_buffer, false)?; + let __out = aiur_fn_202(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 203u64 => { let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_203(__inp, record, io_buffer, false)?; + let __out = aiur_fn_203(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 204u64 => { let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_204(__inp, record, io_buffer, false)?; + let __out = aiur_fn_204(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 205u64 => { let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_205(__inp, record, io_buffer, false)?; + let __out = aiur_fn_205(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 206u64 => { let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_206(__inp, record, io_buffer, false)?; + let __out = aiur_fn_206(QueryKey::new(__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)?; + let __out = aiur_fn_207(QueryKey::new(__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)?; + let __out = aiur_fn_208(QueryKey::new(__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)?; + let __out = aiur_fn_209(QueryKey::new(__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)?; + let __out = aiur_fn_210(QueryKey::new(__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)?; + let __out = aiur_fn_211(QueryKey::new(__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)?; + let __out = aiur_fn_212(QueryKey::new(__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)?; + let __out = aiur_fn_213(QueryKey::new(__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)?; + let __out = aiur_fn_214(QueryKey::new(__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)?; + let __out = aiur_fn_215(QueryKey::new(__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)?; + let __out = aiur_fn_216(QueryKey::new(__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)?; + let __out = aiur_fn_217(QueryKey::new(__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)?; + let __out = aiur_fn_218(QueryKey::new(__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)?; + let __out = aiur_fn_219(QueryKey::new(__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)?; + let __out = aiur_fn_220(QueryKey::new(__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)?; + let __out = aiur_fn_221(QueryKey::new(__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)?; + let __out = aiur_fn_222(QueryKey::new(__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)?; + let __out = aiur_fn_223(QueryKey::new(__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)?; + let __out = aiur_fn_224(QueryKey::new(__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)?; + let __out = aiur_fn_225(QueryKey::new(__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)?; + let __out = aiur_fn_226(QueryKey::new(__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)?; + let __out = aiur_fn_227(QueryKey::new(__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)?; + let __out = aiur_fn_228(QueryKey::new(__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)?; + let __out = aiur_fn_229(QueryKey::new(__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)?; + let __out = aiur_fn_230(QueryKey::new(__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)?; + let __out = aiur_fn_231(QueryKey::new(__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)?; + let __out = aiur_fn_232(QueryKey::new(__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)?; + let __out = aiur_fn_233(QueryKey::new(__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)?; + let __out = aiur_fn_234(QueryKey::new(__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)?; + let __out = aiur_fn_235(QueryKey::new(__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)?; + let __out = aiur_fn_236(QueryKey::new(__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)?; + let __out = aiur_fn_237(QueryKey::new(__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)?; + let __out = aiur_fn_238(QueryKey::new(__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)?; + let __out = aiur_fn_239(QueryKey::new(__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)?; + let __out = aiur_fn_240(QueryKey::new(__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)?; + let __out = aiur_fn_241(QueryKey::new(__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)?; + let __out = aiur_fn_242(QueryKey::new(__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)?; + let __out = aiur_fn_243(QueryKey::new(__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)?; + let __out = aiur_fn_244(QueryKey::new(__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)?; + let __out = aiur_fn_245(QueryKey::new(__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)?; + let __out = aiur_fn_246(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 247u64 => { let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_247(__inp, record, io_buffer, false)?; + let __out = aiur_fn_247(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 248u64 => { let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_248(__inp, record, io_buffer, false)?; + let __out = aiur_fn_248(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 249u64 => { let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_249(__inp, record, io_buffer, false)?; + let __out = aiur_fn_249(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 250u64 => { let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_250(__inp, record, io_buffer, false)?; + let __out = aiur_fn_250(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 251u64 => { let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_251(__inp, record, io_buffer, false)?; + let __out = aiur_fn_251(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 252u64 => { let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_252(__inp, record, io_buffer, false)?; + let __out = aiur_fn_252(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 253u64 => { let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_253(__inp, record, io_buffer, false)?; + let __out = aiur_fn_253(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 254u64 => { let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_254(__inp, record, io_buffer, false)?; + let __out = aiur_fn_254(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 255u64 => { let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_255(__inp, record, io_buffer, false)?; + let __out = aiur_fn_255(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 256u64 => { let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_256(__inp, record, io_buffer, false)?; + let __out = aiur_fn_256(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 257u64 => { let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_257(__inp, record, io_buffer, false)?; + let __out = aiur_fn_257(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 258u64 => { let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_258(__inp, record, io_buffer, false)?; + let __out = aiur_fn_258(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 259u64 => { let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_259(__inp, record, io_buffer, false)?; + let __out = aiur_fn_259(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, 260u64 => { let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); - let __out = aiur_fn_260(__inp, record, io_buffer, false)?; + let __out = aiur_fn_260(QueryKey::new(__inp), record, io_buffer, false)?; return Ok(__out.to_vec()); }, _ => { diff --git a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs index 98c48731c..33db28287 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark_runner.rs @@ -219,7 +219,9 @@ pub fn execute_multi_stark( return Err(ExecError::NotEntryFunction(fun_idx)); } let mut record = QueryRecord::new(toplevel); - let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; + let output = execute_generated(fun_idx, &args, &mut record, io_buffer) + .map_err(|e| record.execution_error(e))?; + record.log_multiplicity_stats("returned"); Ok((record, output)) } diff --git a/lakefile.lean b/lakefile.lean index 98fe391ce..de790bd76 100644 --- a/lakefile.lean +++ b/lakefile.lean @@ -178,6 +178,10 @@ lean_exe «bench-ixvm» where lean_exe «bench-shardmap» where root := `Benchmarks.ShardMap +lean_exe «bench-ixvm-focus» where + root := `Benchmarks.IxVM.FocusFailures + moreLinkObjs := #[ix_rs] + lean_exe «bench-typecheck» where root := `Benchmarks.Typecheck supportInterpreter := true From 3e7586a7adb0c6f3cd3ff5854da832701288ec90 Mon Sep 17 00:00:00 2001 From: "John C. Burnham" Date: Wed, 9 Sep 2026 14:17:53 -0400 Subject: [PATCH 3/3] fix(bench): time effectful shard proving in IO --- Benchmarks/Typecheck.lean | 63 ++++++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 28 deletions(-) diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index e25db3f50..58bc86162 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -378,14 +378,19 @@ def Result.toJsonEntry (executeOnly : Bool) (r : Result) : String × Json := | _, _, _ => fields (r.name, Json.mkObj fields) -/-- Time a thunk, returning its value and the elapsed seconds. The result is - forced by `blackBoxIO` so a pure computation isn't optimized away. -/ -def timed (f : Unit → α) : IO (α × Float) := do +/-- Execute an IO action inside the timing window, returning its result and + elapsed seconds rather than measuring construction of the action. -/ +def timedIO (action : IO α) : IO (α × Float) := do let t0 ← IO.monoNanosNow - let a ← blackBoxIO f () + let a ← action let t1 ← IO.monoNanosNow return (a, (t1 - t0).toFloat / 1e9) +/-- Time a thunk, returning its value and the elapsed seconds. The result is + forced by `blackBoxIO` so a pure computation isn't optimized away. -/ +def timed (f : Unit → α) : IO (α × Float) := + timedIO (blackBoxIO f ()) + def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do let some ixeArg := p.flag? "ixe" | IO.eprintln "error: --ixe is required"; return 1 @@ -650,23 +655,24 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do -- Windowed high-water: each prove's peak is its own window, not -- the run's cumulative maximum (mirrors the Phase-1 resets). TracingTexray.resetPeakTreeRss - let (proveRes, proveSec) ← timed fun _ => + let (proveRes, proveSec) ← timedIO do if skipDeps then - let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr - let proveRes := - if useInterp then - aiurSystem.prove funIdx witness.input witness.inputIOBuffer - else - aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer - proveRes.map fun (claim, proof, ioBuf) => - (claim, proof, ioBuf, (none : Option ByteArray)) + blackBoxIO (fun _ => + let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr + let proveRes := + if useInterp then + aiurSystem.prove funIdx witness.input witness.inputIOBuffer + else + aiurSystem.proveIxVM funIdx witness.input witness.inputIOBuffer + proveRes.map fun (claim, proof, ioBuf) => + (claim, proof, ioBuf, (none : Option ByteArray))) () else if join then - match aiurSystem.shardProveWithEnv funIdx envHandle + match ← aiurSystem.shardProveWithEnv funIdx envHandle (singletonOwnedBlob addr) with - | .error e => .error e + | .error e => return .error e | .ok result => match result.proof with | none => - .error s!"projected prover peak {result.peakBytes} bytes exceeds \ + return .error s!"projected prover peak {result.peakBytes} bytes exceeds \ the budget; suggested {result.suggestedParts} parts" | some proof => let digest := Address.blake3 result.claimBytes @@ -674,19 +680,20 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[] -- Shard proving no longer returns its whole ingested IO scope; -- this benchmark never reads it after the proof is produced. - .ok (claim, proof, default, some result.claimBytes) + return .ok (claim, proof, default, some result.claimBytes) else - match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash useInterp with - | .error e => .error e - | .ok (claimBytes, proof, ioBuf) => - -- The envHandle path returns the SERIALIZED `Ix.Claim`; rebuild - -- the Array-G claim `verify` takes — `verify_claim`'s input is - -- the 32-G blake3 digest of those bytes (same recipe as - -- `ix verify`). - let digest := Address.blake3 claimBytes - let claim := - Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[] - .ok (claim, proof, ioBuf, none) + blackBoxIO (fun _ => + match aiurSystem.proveAddrWithEnv funIdx envHandle addr.hash useInterp with + | .error e => .error e + | .ok (claimBytes, proof, ioBuf) => + -- The envHandle path returns the SERIALIZED `Ix.Claim`; rebuild + -- the Array-G claim `verify` takes — `verify_claim`'s input is + -- the 32-G blake3 digest of those bytes (same recipe as + -- `ix verify`). + let digest := Address.blake3 claimBytes + let claim := + Aiur.buildClaim funIdx (IxVM.ClaimHarness.packedDigestKey digest) #[] + .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